Manejo de tablas en SQL Server: CREATE TABLE, ALTER TABLE y DROP TABLE.

Bien, antes de continuar te recomiendo que revises las siguientes clases para que hagas un repaso y comprendas todo lo que respecta a tablas:

• Modelo relacional
• Normalización base de datos
• Modelo entidad relación

⚠️ NOTA: recuerda que SQL Server utiliza el lenguaje Transact-SQL (T-SQL) el cual es una variante mejorada del lenguaje SQL, por lo tanto, cada comando lo intentaré hacer lo más apegado a SQL, pero, si hay que profundizar en cada comando, lo haré tomando en cuenta la sintaxis que proporciona Transact-SQL.

Conceptos básicos de tablas

Antes de continuar, repasamos algunos conceptos que vimos anteriormente:

• Una llave primaria o Primary Key en ingles: es aquella columna dentro de nuestra tabla que hemos elegido para definir de manera unívocamente a cada una de nuestras filas.
• Una llave foránea o Foreign Key: es una referencia a una clave de otra tabla, las claves foráneas no requieren ser datos únicos en la tabla donde se localizan, pero si lo deben ser en la tabla de referencia.
• Un índice: es similar al índice de un libro, ya que, nos servirá para realizar búsquedas más rápidas dentro de nuestra tabla.

Bien, ahora si empecemos con la parte principal de este post.

CREATE TABLE: ¿Cómo crear una tabla en SQL Server?

Bien, el primer comando con el que vamos a trabajar es CREATE TABLE, no obstante, dado que T-SQL nos proporciona una gran cantidad de opciones, solo veremos algunos casos básicos, ya que, no quiero que te confundas y vayas aprendiendo paso a paso.

¿Qué es CREATE TABLE y para que sirve?

El comando CREATE TABLE nos permite crear una tabla dentro de una base de datos, además, podemos definir la llave primaria y cada tipos de dato de los atributos.

Excelente, creo que la definición es fácil de comprender, así que, continuemos con esta introducción a SQL y revisemos la sintaxis básica de este comando.

Sintaxis T-SQL: CREATE TABLE

CREATE TABLE
    { database_name.schema_name.table_name | schema_name.table_name | table_name }
    ( { <column_definition> } [ ,...n ] )
[ ; ]

<column_definition> ::=
column_name <data_type>
    [ FILESTREAM ]
    [ COLLATE collation_name ]
    [ SPARSE ]
    [ MASKED WITH ( FUNCTION = 'mask_function') ]
    [ [ CONSTRAINT constraint_name ] DEFAULT constant_expression ]
    [ IDENTITY [ ( seed , increment ) ]
    [ NOT FOR REPLICATION ]
    [ GENERATED ALWAYS AS { ROW | TRANSACTION_ID | SEQUENCE_NUMBER } { START | END } [ HIDDEN ] ]
    [ NULL | NOT NULL ]
    [ ROWGUIDCOL ]
    [ ENCRYPTED WITH
        ( COLUMN_ENCRYPTION_KEY = key_name ,
          ENCRYPTION_TYPE = { DETERMINISTIC | RANDOMIZED } ,
          ALGORITHM = 'AEAD_AES_256_CBC_HMAC_SHA_256'
        ) ]
    [ <column_constraint> [, ...n ] ]
    [ <column_index> ]
    
<column_constraint> ::=
[ CONSTRAINT constraint_name ]
{ 
   { PRIMARY KEY | UNIQUE }
        [ CLUSTERED | NONCLUSTERED ]
        [
            WITH FILLFACTOR = fillfactor
          | WITH ( <index_option> [ , ...n ] )
        ]
        [ ON { partition_scheme_name ( partition_column_name )
            | filegroup | "default" } ]
  
  | [ FOREIGN KEY ]
        REFERENCES [ schema_name. ] referenced_table_name [ ( ref_column ) ]
        [ ON DELETE { NO ACTION | CASCADE | SET NULL | SET DEFAULT } ]
        [ ON UPDATE { NO ACTION | CASCADE | SET NULL | SET DEFAULT } ]
        [ NOT FOR REPLICATION ]
  
  | CHECK [ NOT FOR REPLICATION ] ( logical_expression )
}
    
<column_index> ::=
 INDEX index_name [ CLUSTERED | NONCLUSTERED ]
    [ WITH ( <index_option> [ ,... n ] ) ]
    [ ON { partition_scheme_name (column_name )
         | filegroup_name
         | default
         }
    ]
    [ FILESTREAM_ON { filestream_filegroup_name | partition_scheme_name | "NULL" } ]

<index_option> ::=
{
    PAD_INDEX = { ON | OFF }
  | FILLFACTOR = fillfactor
  | IGNORE_DUP_KEY = { ON | OFF }
  | STATISTICS_NORECOMPUTE = { ON | OFF }
  | STATISTICS_INCREMENTAL = { ON | OFF }
  | ALLOW_ROW_LOCKS = { ON | OFF }
  | ALLOW_PAGE_LOCKS = { ON | OFF }
  | OPTIMIZE_FOR_SEQUENTIAL_KEY = { ON | OFF }
  | COMPRESSION_DELAY= { 0 | delay [ Minutes ] }
  | DATA_COMPRESSION = { NONE | ROW | PAGE | COLUMNSTORE | COLUMNSTORE_ARCHIVE }
       [ ON PARTITIONS ( { partition_number_expression | <range> }
       [ , ...n ] ) ]
}

El código anterior es la sintaxis de CREATE TABLE, no obstante, resaltare los parámetros que utilizaremos en los siguientes ejemplos, por lo tanto, te dejo el link a la documentación por si quieres revisar a detalle: fuente:

• database_name (opcional): nombre de la base de datos, si no se define la base de datos explícitamente, antes de bese de ejecutar use database, para posicionarte en la base de datos en que debes trabajar.
• schema_name (opcional): nombre del esquema al que perecerá la tabla.
  • El schema es un conjunto lógico, digamos que es una forma en que podemos organizar, tablas, vistas, etc.
  • Si el schema no es definido, la tabla se agrega al schema “dbo”.
• table_name: nombre de la nueva tabla, no debe sobrepasar los 128 caracteres.
• column_definition: representa la definición de nuestras columnas de la tabla o atributos.
• column_name: nombre de la columna o atributo.
• data_type: tipo de dato, SQL Server maneja una gran variedad de tipos de datos, algunos ya los vimos en el primer vídeo del curso de base de datos, por ejemplo:
  • bigint: entero de 8 bytes
  • int: entero de 4 bytes
  • float: numérico de punto flotante
  • date: tipo fecha año, mes y día.
  • varchar: cadena de caracteres.
  • Etc.
• IDENTITY: auto incremental, el motor de la base de datos proporciona un valor incremental único para el atributo o columna en cuestión.
• NULL: indica que la columna acepta valores nulos.
• NOT NULL: indica que la columna o atributo no acepta valores nulos.
• column_constraint: parámetros referentes con la definición de llaves y restricciones.
• PRIMARY KEY: representa nuestra llave primaria.
• column_index: definición de índices.
• INDEX: permite definir un atributo como índice.
• index_option: permite establecer las propiedades de nuestro índice.
• FILLFACTOR: permite ajustar el rendimiento y almacenamiento de datos de un índice.

Como puedes ver, he definido los parámetros que vamos a utilizar, en la documentación tienes toda la información referente a cada argumento.

Ejemplo CREATE TABLE: ¿Cómo crear una tabla en SQL Server con PRIMARY KEY, autoincremental e índice?

Bien, para este ejemplo vamos a utilizar el ejemplo que hicimos en la clase Diagrama entidad relación, donde diseñamos algunas tablas respectos a Equipos GPS:

Como puedes observar, vamos a crear los siguientes campo:

• IMEI (y lo declararemos como índice)
• RFC
• Celular
• SIM
• Fabricante
• Modelo
• Protocolo
• Estatus
• Fecha
• Además agregaremos una columna id que será PRIMARY KEY y autoincremental.

CREATE TABLE: Creando una tabla en SQL Server a través de código

Para este primer ejemplo vamos a utilizar CREATE TABLE de forma básica, ya que agregaremos a la tabla:

• Un atributo autoincremental
• Definiremos quien es nuestra llave primaría
• Y también crearemos un índice.

USE ewebikdb;
CREATE TABLE equipos_gps (
	id			INT NOT NULL IDENTITY(1,1) INDEX i_eg_id CLUSTERED WITH (FILLFACTOR = 70),
	imei		VARCHAR(16) NOT NULL DEFAULT '0' PRIMARY KEY,
	rfc			VARCHAR(16) NOT NULL DEFAULT '-' INDEX i_eg_rfc NONCLUSTERED WITH (FILLFACTOR = 70),
	celular		VARCHAR(15) NOT NULL DEFAULT '0',
	sim			VARCHAR(50) NOT NULL DEFAULT '0',
	fabricante	VARCHAR(50) NOT NULL DEFAULT '-',
	modelo		VARCHAR(50) NOT NULL DEFAULT '-',
	protocolo	VARCHAR(50) NOT NULL DEFAULT '-',
	estatus		SMALLINT NOT NULL DEFAULT 0,
	fecha		DATE NOT NUll DEFAULT GETUTCDATE()
)

Revisemos un poco el código:

• equipos_gps: nombre de la base de datos, tu le puedes poner el nombre que desees, yo acostumbro separar las palabras con guiones bajos.
• columnas o atributos: la definción de nuestros atributos es una lista que debes poner entre los paréntesis y separados por comas.
• Utilizamos los tipos de datos: INT, VARCHAR, SMALLINT y DATE.
• NOT NULL: ninguno de nuestros atributos aceptas valores nulos.
• DEFAULT: ya que los atributos no aceptas valores nulos, establecemos un valor por default, para el caso de “fecha” acostumbro siempre manejar datos en UTC-0, por lo tanto, el valor por default es lo establezco a través de la función GETUTCDATE() que devuelve la fecha en UTC-0.
• IDENTITY(1,1): indicamos que el atributo es autoincremental que inicia en 1 y su incremento debe darse en 1.
• PRIMARY KEY: indicamos que el atributo imei es nuestra llave primaría.
• INDEX: nos permite indicar que el atributo “id” y “rfc” serán índices, por lo tanto, tenemos que indicar el comportamiento de estos índices:
  • i_eg_id e i_eg_rfc: nombre de el índice, la sintaxis que suelo seguir es separar las palabras con guiones bajos, iniciando con la letra “i” seguido de las iniciales del nombre de la tabla y, finalizo el nombre del atributo.
  • CLUSTERED: agrupa los datos, y los datos son ordenados respecto a esta columna, una tabla sólo puede tener un índice CLUSTERED,
  • NONCLUSTERED: agrupas los datos, pero, no es necesarios ordenarlos, esto suelo hacerlo así cuando requiero de una llave y esta es texto, ya que, cuando se reconstruye el índice, no es necesario que los datos se orden.
  • FILLFACTOR: es un parámetro que podríamos traducir como “factor de relleno”, su funcionamiento es algo complejo, y dado que estamos en la parte básica de este curso, quédate con que estamos ajustando el rendimiento y almacenamiento de datos del índice.

Y listo, hemos creado nuestra primera tabla, pero no cualquier tabla, hemos creador una tabla que aunque simple, tiene varias cosas que utilizarás en la practica: definición de llave primaria, declaración de un autoincremental y la creación de un índice.

📌 NOTA: en el ejemplo hemos creado un índice durante la creación de la tabla, no obstante, existen comandos que nos permiten crear índices en tablas existentes, pero, eso lo veremos en siguientes clases.

¿Cómo crear una tabla temporal en SQL Server?

Bien, ahora revisemos el tema de tablas temporales, las cuales son bastante útiles en la practica, sobre todo, cuando creamos lo que se llaman procedimientos almacenados (stored procedure), los cuales, veremos más adelante, por lo proto veamos de que trata este concepto.

¿Qué son las tablas temporales y para que sirven?

En SQL Server son un tipo de tabla que se crean en la base de datos tempdb y proveen un espacio temporal donde podemos escribir datos y recuperarlos, antes de procesarlos y grabarlos en nuestras tablas que forman parte de nuestra aplicación.

Utilidad de las tablas temporales

Una tabla temporal es sumamente útil, ya que, podemos extraer datos de nuestras tablas y almacenarlos temporalmente en estas tablas, ya sea, para operarlos y trabajar con esos datos sin alterar, bloquear o estresar, nuestras tablas reales, y al final, podemos consultar esos datos temporales o insertarlos en nuestras tablas permanentes.

Es importante mencionar que una tabla temporal:

• Puede ser accedida únicamente desde la sesión actual.
• O puede ser una tabla temporal global y acceder a ella desde varias sesiones.

Ejemplo: ¿Cómo crear una tabla temporal local en SQL Server?

Para crear una tabla temporal en SQL Server de forma local, lo vamos hacer muy similar a la sintaxis que anteriormente vimos, solo que, al nombre de la tabla le vamos anteponer el símbolo numeral o hashtag (#), por ejemplo:

create table #equipos_temp(
	imei		VARCHAR(16) NOT NULL DEFAULT '0',
	rfc			VARCHAR(16) NOT NULL DEFAULT '-',
	celular		VARCHAR(15) NOT NULL DEFAULT '0',
	sim			VARCHAR(50) NOT NULL DEFAULT '0',
	fabricante	VARCHAR(50) NOT NULL DEFAULT '-',
	modelo		VARCHAR(50) NOT NULL DEFAULT '-',
	protocolo	VARCHAR(50) NOT NULL DEFAULT '-',
	estatus		SMALLINT NOT NULL DEFAULT 0,
	fecha		DATE NOT NUll DEFAULT GETUTCDATE()
)

• Como puedes observar, hemos creado la tabla temporal #equipos_temp.
• Esta tabla es prácticamente la misma a la tabla equipos_gps que creamos anteriormente, lo he hecho así para que te des cuenta que esta tabla la podemos utilizar para extraer datos y operarlos fuera de la tabla original.
• Esta tipo de tabla temporal que lleva un solo símbolo numeral o hashtag (#), solo puede ser accedida desde la sesión actual y sus sesiones inferiores o anidadas, pero, las sesiones paralelas a ella o superiores no podrán acceder a esta tabla.

Ejemplo: ¿Cómo crear una tabla temporal global en SQL Server?

Ahora, quizá lo que necesites es operar datos temporales desde varias sesiones abiertas, para ello vamos a utilizar tablas temporales globales, las cuales, las podemos declarar a través de anteponer al nombre de la tabla un doble símbolo numeral o hashtag (#), por ejemplo:

create table ##equipos_temp(
	imei		VARCHAR(16) NOT NULL DEFAULT '0',
	rfc			VARCHAR(16) NOT NULL DEFAULT '-',
	celular		VARCHAR(15) NOT NULL DEFAULT '0',
	sim			VARCHAR(50) NOT NULL DEFAULT '0',
	fabricante	VARCHAR(50) NOT NULL DEFAULT '-',
	modelo		VARCHAR(50) NOT NULL DEFAULT '-',
	protocolo	VARCHAR(50) NOT NULL DEFAULT '-',
	estatus		SMALLINT NOT NULL DEFAULT 0,
	fecha		DATE NOT NUll DEFAULT GETUTCDATE()
)

• Y con tan solo poner el doble  numeral o hashtag, hemos creado una tabla temporal que puede ser accedida des cualquier sesión abierta en ese mosmento.

Ejemplo: ¿Cómo crear una variable tipo tabla en SQL Server?

También existe la posibilidad de crear una tabla temporal, las cuales, se declaran como cualquier variable en SQL Server, no obstante, esta tabla temporal sólo podrá ser accedida desde la sesión actual únicamente, veamos como crear una variable tipo tabla.

DECLARE @equipos_temp AS TABLE(
	imei		VARCHAR(16) NOT NULL DEFAULT '0',
	rfc			VARCHAR(16) NOT NULL DEFAULT '-',
	celular		VARCHAR(15) NOT NULL DEFAULT '0',
	sim			VARCHAR(50) NOT NULL DEFAULT '0',
	fabricante	VARCHAR(50) NOT NULL DEFAULT '-',
	modelo		VARCHAR(50) NOT NULL DEFAULT '-',
	protocolo	VARCHAR(50) NOT NULL DEFAULT '-',
	estatus		SMALLINT NOT NULL DEFAULT 0,
	fecha		DATE NOT NUll DEFAULT GETUTCDATE()
)

• Como puedes observar, solo cambiamos el CREATE por DECLARE y al nombre de la tabla le anteponemos un @, y a través de “AS”, indicamos que esa variable es tipo tabla.

¿Qué es mejor una variable tipo tabla o una tabla temporal?

La respuesta a esta pregunta realmente es un depende, necesitaríamos profundizar más en la sintaxis que proporciona T-SQL para este tipo de objetos y la optimización de memoria, no obstante, podemos indicar lo siguiente:

• Tanto las variables tipo tabla como las tablas temporales, se crean en la base de datos tempdb, así que respecto a esto no hay diferencias sustanciales.
• Ahora, si vas a operar un número reducido de datos temporales, quizá una variable tipo tabla es suficiente.
• Pero, si vas a operar una gran cantidad de datos temporales, lo que presenta mejor rendimiento es una tabla temporal.

Seguramente te estas preguntando ¿Pero cuanto son muchos o pocos datos? Para ello si no tengo una respuesta, pues depende mucho de tu aplicación, puedes probar con ambas y analizar cual presenta mejor rendimiento.

📌 NOTA: las tablas temporales pueden y te recomiendo eliminarlas a través de DROP TABLE, cuando en tu código ya no las necesitas, además, no puedes declarar dos tablas temporales con el mismo nombre. Pero DROP TABLE lo veremos más adelante en este post.

ALTER TABLE: ¿Cómo agregar o eliminar columnas de una tabla en SQL Server?

Si bien T-SQL proporciona una gran cantidad de opciones que podemos ejecutar sobre una tabla, muchas de ellas salen del objetivo de este post, por lo tanto, para ir paso a paso, vamos hacer un par de ejemplos de como podemos agregar una columna o eliminar una columna.

Entonces, sigamos con la tabla de “Equipos GPS”, si recordamos nuestra clase del modelo entidad relación, dicha tabla tiene una redundancia evidente, ya que, los atributos;

• Fabricante
• Modelo
• Y Protocolo

Se repetirán muchas veces, así que, como vimos en nuestra clase de normalización de base de datos, podemos eliminar esta redundancia separando los atributos en otra tabla, por ejemplo:

Por lo tanto:

• Debemos crear una nueva tabla “Tipos GPS” y agregar los campos: Fabricante, Modelo y Protocolo.
• Por otra parte debemos eliminar dichos campos en “Equipos GPS” y agregar el nuevo campo “Cod gps”.

¿Qué es ALTER TABLE y para que sirve?

ALTER TABLE, permite modificar características de una tabla existente, como agregar o eliminar columnas.

ALTER TABLE: sintaxis para agregar una nueva columna

ALTER TABLE table_name
ADD column_name datatype;

Como puedes observar la sintaxis para este caso es bastante simple, solo necesitamos:

• Indicar el nombre de la tabla: table_name.
• Y a través de ADD definir las características de nuestra nueva columna.

Ejemplo ALTER TABLE: ¿Cómo agregar una columna a una tabla en SQL Server?

Primero crearemos la table “Tipos GPS”:

USE ewebikdb;

CREATE TABLE tipos_gps(
	cod_gps		INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
)

• Hemos creado la tabla únicamente con su llave primaria.
• Ahora a través de ALTER TABLE, agreguemos los campos que hacen falta, se que pudimos agregar los campos desde el principio, pero, el objetivo es ejemplificar el agregar nuevas columnas.

Agregando nuevas columnas a una tabla existente en SQL Server

USE ewebikdb;

ALTER TABLE	tipos_gps
ADD		
	fabricante		VARCHAR(50) NOT NULL DEFAULT '-',
	modelo			VARCHAR(50) NOT NULL DEFAULT '-',
	protocolo		VARCHAR(50) NOT NULL DEFAULT '-'
;

• Como puedes observar, la sintaxis es muy simple, definimos el campo y especificamos sus características, que para este caso:
  • VARCHAR
  • NOT NULL
  • DEFAULT es un guion medio.

Y eso es todo, agregar columnas de esta manera es muy fácil, continuemos con los siguientes ejemplos.

Ejemplo ALTER TABLE: ¿Cómo eliminar un campo de una tabla (DROP COLUMN) en SQL Server?

Bien ahora, ya hemos creado nuestra nueva tabla y hemos agregado nuevos campos, solo falta que en “Equipos GPS” eliminemos las columnas:

• Fabricante
• Modelo
• Protocolo

Para ello utilizaremos DROP COLUMN y ALTER TABLE, por ejemplo:

Eliminando atributos de una tabla en SQL Server

USE ewebikdb;

ALTER TABLE	equipos_gps
DROP COLUMN		
	fabricante,
	modelo,
	protocolo
;

• La sintaxis del código anterior, es correcta, sin embargo, al ejecutarlo SQL Server mostrará un error y la columna no se eliminará.
• Este error se da, debido a que, SQL Server crea una dependencia y hay que eliminar esa dependencia antes de eliminar la columna.
• Para obtener el nombre de dicha dependencia, puedes ejecutar el comando para cada columna, por ejemplo:

• El ejecutar el anterior comando por cada columna obtendremos los nombres:
  • DF__equipos_g__fabri__398D8EEE
  • DF__equipos_g__model__3A81B327
  • DF__equipos_g__proto__3B75D760
• Ahora solo utilizaremos DROP CONSTRAINT para eliminar ese objeto, para después, intentar eliminar las columnas nuevamente.

USE ewebikdb;

ALTER TABLE	equipos_gps
DROP CONSTRAINT
	DF__equipos_g__fabri__398D8EEE,
	DF__equipos_g__model__3A81B327,
	DF__equipos_g__proto__3B75D760
;

• Ahora que ya hemos eliminado la dependencia, podemos ejecutar nuevamente la consulta con nuestro DROP COLUMN y podremos eliminar las columnas.

Ejemplo ALTER TABLE: ¿Cómo crear una llave foránea (FOREIGN KEY) en SQL Server?

Excelente, ya casi terminamos de modificar nuestras tablas, ahora lo que vamos hacer es crear una llave foránea (FOREIGN KEY) a la tabla “Equipos GPS” que hará referencia al campo “cod_gps” de la tabla “Tipos GPS”.

• Primero agreguemos esta nueva columna “cod_gps” en “Equipos GPS”.

USE ewebikdb;

ALTER TABLE	equipos_gps
ADD		
	cod_gps	INT NOT NULL DEFAULT 0
;

• Excelente,, ahora que ya tenemos nuestra nueva columna, crearemos nuestra FOREIGN KEY.

ALTER TABLE equipos_gps
ADD CONSTRAINT fk_cod_gps FOREIGN KEY (cod_gps)
      REFERENCES tipos_gps (cod_gps)
      ON DELETE CASCADE
      ON UPDATE CASCADE
;

Del código anterior podemos destacar:

• Vamos a modificar la tabla: equipos_gps.
• CONSTRAINT: creamos una restricción fk_cod_gps indicando que será una llave foránea (FOREIGN KEY) de cod_gps.
• Con REFERENCES establecemos que la tabla de referencia para esta llave foránea será tipos_gps en la columna cod_gps, yo acostumbro poner el mismo nombre en ambas tablas.
• DELETE CASCADE y UPDATE CASCADE: se utilizan para garantizar que todos los cambios realizados en la tabla de referencia tipos_gps se propaguen automáticamente a la tabla equipos_gps.

Y listo, ya hemos creado nuestra primera llave foránea, la cual relaciona nuestra tabla equipos_gps y tipos_gps, además, hemos normalizado nuestras tablas eliminando las redundancias que habían.

Eliminando tablas en SQL

Muy bien, ahora pasemos a ver como podemos eliminar una tabla por completo utilizando SQL, para esta instrucción debes tener mucho cuidado, sobre todo si vas empezando en este mundo de base de datos, ya que, una vez que eliminas una tabla y no tienes respaldo, no la podrás recuperar, así que ten cuidado.

¿Qué es DROP TABLE y para que sirve?

DROP TABLE es un comando que nos permite eliminar una tabla existente dentro de una base de datos.

DROP TABLE: sintaxis para eliminar una tabla en T-SQL

DROP TABLE [ IF EXISTS ] { database_name.schema_name.table_name | schema_name.table_name | table_name } [ ,...n ]  
[ ; ]  

• Como puedes ver es una sintaxis muy simple y fácil de entender.

Ejemplo DROP TABLE: ¿Cómo eliminar una tabla en SQL Server?

Bien, para este ejemplo vamos a crear una nueva tabla, debido a que, no quiero eliminar las tablas que hemos creado, ya que, las vamos a utilizar seguramente en clases siguientes.

USE ewebikdb;

CREATE TABLE ewebik_temp(
	id		INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
	imei		VARCHAR(16) NOT NULL INDEX i_eg_imei NONCLUSTERED WITH (FILLFACTOR = 70),
	rfc			VARCHAR(16) NOT NULL DEFAULT '-',
	celular		VARCHAR(15) NOT NULL DEFAULT '0',
)

• Bien, ahora si eliminemos nuestra tabla ewebik_temp.

USE ewebikdb;

DROP TABLE IF EXISTS ewebik_temp;

Listo, hemos eliminado nuestra primera tabla desde SQL, pero recuerda, no hagas esto en producción a menos que sepas y estés seguro lo que estas haciendo.

Excelente, hemos llegado al final, hoy has aprendido:

• A crear tablas.
• Modificar tablas
• Y eliminar tablas

Pero también vimos:

• Crear campos autoincreméntales.
• Especificar índices.
• Declarar la llave primaria y foránea.

Como ves, fueron muchas cosas, ahora practica para afianzar lo aprendido, nos vemos en el siguiente post.