sql >> Base de Datos >  >> RDS >> Mysql

CREATE TABLE MySQL vs T-SQL con ejemplos de sintaxis

¿Es usted un desarrollador de T-SQL que está aprendiendo los conceptos básicos de MySQL? Entonces, una de las cosas que tal vez quiera aprender es la instrucción CREATE TABLE de MySQL. Además, la forma más rápida de aprender una nueva plataforma de base de datos SQL es comparar su funcionalidad y sintaxis comunes.

Eso es lo que vamos a hacer hoy. Pero la sintaxis completa es mucha. Por lo tanto, solo cubriremos 5 puntos básicos para que pueda comenzar a utilizar el comando MySQL CREATE TABLE.

Sin embargo, antes de continuar, aclaremos algunos puntos:

  1. La versión de MySQL utilizada aquí es MySQL 8 con el motor de almacenamiento InnoDB.
  2. La versión de SQL Server utilizada aquí es SQL Server 2019.

¿Suena bien? Comencemos.

Crear declaración de tabla en MySQL y T-SQL

Comencemos la comparación definiendo el nombre de la tabla.

Una de las diferencias de sintaxis notables en MySQL CREATE TABLE es la ausencia de un nombre de esquema. Así es como funciona:

CREATE TABLE database_name.table_name

¿Notó el nombre de la tabla precedido por el nombre de la base de datos? Ahora, aquí hay un formato equivalente a T-SQL con el que está familiarizado:


CREATE TABLE database_name.schema_name.table_name

¿Por qué? Porque en MySQL, un esquema es sinónimo de una base de datos. Los nombres de la base de datos y el esquema son opcionales. Sin embargo, si necesita crear una tabla en otra base de datos en el mismo script, esto es obligatorio.

Así es. El uso de corchetes en los nombres de tablas y columnas generará un error en MySQL. En su lugar, debe usar un par de acentos graves para encerrar los identificadores. La Figura 1 muestra dónde lo encuentra en un diseño de teclado de EE. UU.:

Ahora, echa un vistazo a la muestra:

-- MySQL CREATE TABLE

CREATE TABLE `testdatabase`.`person` (
  `BusinessEntityID` INT NOT NULL,
  `PersonType` NCHAR(2) NOT NULL,
  `Title` VARCHAR(8) NULL,
  `FirstName` NVARCHAR(50) NOT NULL,
  `MiddleName` VARCHAR(50) NULL,
  `LastName` VARCHAR(50) NOT NULL,
  `Suffix` NVARCHAR(10) NULL,
  `EmailPromotion` INT NOT NULL,
  `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
  PRIMARY KEY (`BusinessEntityID`));

Del ejemplo de código anterior, los identificadores de nombres de tablas y columnas se incluyen entre comillas graves. Si no está acostumbrado a incluir nombres de tablas y columnas con esto, créame, no está solo.

Compruebe el código equivalente en T-SQL a continuación:

-- T-SQL CREATE TABLE
CREATE TABLE [testdatabase].[dbo].[Person](
	[BusinessEntityID] [int] NOT NULL,
	[PersonType] [nchar](2) NOT NULL,
	[Title] [nvarchar](8) NULL,
	[FirstName] [nvarchar](50) NOT NULL,
	[MiddleName] [nvarchar](50) NULL,
	[LastName] [nvarchar](50) NOT NULL,
	[Suffix] [nvarchar](10) NULL,
	[EmailPromotion] [int] NOT NULL,
	[ModifiedDate] [datetime] NOT NULL DEFAULT GETDATE(),
 CONSTRAINT [PK_Person_BusinessEntityID] PRIMARY KEY  
  (
	[BusinessEntityID] ASC
  )
) ON [PRIMARY]

Por supuesto, no es necesario que incluya estos identificadores. Pero si usa palabras de reserva o espacios en los nombres de tablas o columnas, se producirá un error.

Cómo Crear tabla temporal

¿Aficionado a las mesas temporales? Entonces MySQL le permitirá escribir más para definir una tabla temporal. Echa un vistazo a la muestra:

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

Mientras tanto, los codificadores T-SQL se utilizan para el # símbolo antes del nombre de la tabla. Ver el código equivalente de lo anterior:


-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

Hemos terminado con las definiciones y los nombres de las tablas. Procedamos con las definiciones de columna.

Sintaxis de columnas de MySQL

No puede tener una tabla SQL básica sin columnas. Entonces, ¿qué similitudes y diferencias hay entre MySQL y SQL Server?

Nombres de columnas y tipos de datos

Ya sabes lo de los backticks. Cualquier otra cosa básica sobre nombres de columnas y tipos de datos es la misma en MySQL y T-SQL. Vea el ejemplo a continuación:

CREATE TABLE `testdatabase`.`people`
(
    `ID` INT,
    `LastName` VARCHAR(50),
    ...
);

Sin embargo, hay más.

Capacidad de nulidad de columna

Las columnas pueden ser anulables o no. Puede hacerlo agregando NULL o NOT NULL en la definición de la columna.

Ampliemos nuestro ejemplo anterior.

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     ...
);

Es más o menos lo mismo que T-SQL. ¿Qué hay de los valores predeterminados?

Valores predeterminados de columna

A continuación se encuentran los valores predeterminados de la columna. Estos son útiles cuando inserta un registro pero no especificó un valor específico para una columna. Ampliemos un poco más nuestro ejemplo anterior:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
     ...
);

La fecha de modificación la columna tiene por defecto la fecha y hora actual del sistema. Si hace un INSERT en esta tabla como el que se muestra a continuación, siempre habrá un valor para ModifiedDate .

INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName)
VALUES
(1,'Kirk','James','Tiberius');

Funciona como se esperaba después de INSERTAR. Aquí hay una captura de pantalla de dbForge Studio para MySQL:

Crear tabla MySQL con claves primarias, externas y únicas

Como en cualquier plataforma SQL, puede definir reglas en los datos de las columnas de la tabla usando restricciones en MySQL. Como esto es importante para el diseño de la mesa, debemos considerar el siguiente punto.

Un desarrollador de T-SQL debe sentirse como en casa con las claves primarias, las claves externas y las claves únicas de MySQL.

Clave principal

Puede definir una o más columnas para que sean la clave principal. La sintaxis es casi la misma que en SQL Server. ¿Alguna excepción? Sí. Es el uso de índices agrupados y no agrupados. Pero dejemos la discusión de este en la siguiente sección.

Por ahora, nos enfocamos en la sintaxis de las claves primarias. Este es el mismo ejemplo que teníamos antes, pero agregamos la columna ID como clave principal:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL PRIMARY KEY,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW()
);

Fácil, ¿no?

Pero, ¿y si necesita varias columnas? Como en T-SQL, tienes 2 opciones. Compruebe los ejemplos a continuación:

-- OPTION 1: Let MySQL generate the constraint name

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
     PRIMARY KEY (`LastName`,`FirstName`,`MiddleName`)
);

-- OPTION 2: Specify your constraint name

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `pk_name` PRIMARY KEY (`LastName`, `FirstName`, `MiddleName`)
);

Eso es todo para las claves principales.

Clave foránea

Otra restricción importante es la clave externa. Esto se usa para hacer referencias cruzadas de una tabla a otra tabla:

CREATE TABLE `testdatabase`.`address`
(
    `ID` int NOT NULL PRIMARY KEY,
    `parent_id` int NOT NULL,
    `full_address` varchar(100) NOT NULL,
    CONSTRAINT `FK_address_parent_id` FOREIGN KEY (`parent_id`)
    REFERENCES `people` (`ID`)
);

¿Viste la similitud con T-SQL?

Clave única

A veces, desea asegurarse de que los datos insertados en una tabla sean únicos. MySQL también admite claves únicas. He aquí un ejemplo:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `PK_people_id` PRIMARY KEY (`ID`),
    CONSTRAINT `IDX_name` UNIQUE KEY (`LastName`,`FirstName`,`MiddleName`)

);

El código anterior garantizará que solo se agreguen nombres únicos a la tabla.

Crear ejemplos de índices de tabla (agrupados y no agrupados)

En los ejemplos anteriores, ha visto crear claves primarias y secundarias. Pero, ¿dónde están los índices agrupados y no agrupados? Eso es notable porque en SQL Server especifica explícitamente la palabra clave CLUSTERED para crear un índice agrupado.

La parte interesante es que MySQL no tiene palabras clave CLUSTERED o NONCLUSTERED. ¿Cómo se crean índices agrupados?

Sencillo. Simplemente especifique la(s) columna(s) como la clave principal, y el motor de almacenamiento InnoDB lo convertirá en un índice agrupado. En el siguiente ejemplo, ID es la clave principal Y el índice agrupado.

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `IDX_name` UNIQUE KEY (`LastName`,`FirstName`,`MiddleName`)
);

Si no especifica una clave principal, cualquier índice único se utilizará como índice agrupado.

Por otra parte, si no tiene una clave principal y un índice único, InnoDB crea un índice agrupado oculto. Verifique la prueba aquí.

La siguiente pregunta es, ¿qué tal un índice no agrupado?

Si ya tiene una clave principal como índice agrupado, cualquier otro índice será no agrupado o secundario. Además, solo puede tener un índice agrupado.

La siguiente sección discutirá una sintaxis única para MySQL CREATE TABLE que no se encuentra en T-SQL.

Sintaxis de clonación y copia de tablas MySQL

Hablemos de la clonación de tablas. Podemos hacerlo en MySQL CREATE TABLE. Luego, mostraremos el equivalente de T-SQL.

El siguiente ejemplo crea la tabla con la misma estructura que la primera tabla usando CREATE TABLE…LIKE.

CREATE TABLE `people2` LIKE `people`

Acabamos de clonar a las personas tabla en personas2 . Sin embargo, es sólo la estructura de las personas tabla que se ha copiado, no los datos. También copió las restricciones clave y los índices de la tabla original. Bastante útil, si me preguntas.

El equivalente T-SQL más cercano es este:

-- T-SQL way of cloning a table. The indexes & key constraints are not included, 
-- though

SELECT * INTO people2
FROM people
WHERE 1=0     -- this will cause the SELECT to return an empty result set.

Pero, ¿y si quieres los datos? Entonces, CREAR TABLA…SELECCIONAR es la respuesta:

CREATE TABLE `people3` AS
SELECT * FROM `people`;

Cualquier dato que esté en las personas tabla, se copiará en la personas3 mesa. Sin embargo, este comando no incluirá índices ni restricciones.

Ahora, el equivalente T-SQL más cercano es este:

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Conclusión

Espero que los puntos anteriores puedan ayudarlo a usar MySQL CREATE TABLE desde la perspectiva de un desarrollador de SQL Server T-SQL.

Algunos de ustedes preferirán usar herramientas gráficas. Pero más adelante, se encontrará buscando una referencia cuando necesite crear tablas de trabajo en sus procedimientos almacenados o scripts ad-hoc. O simplemente eres del tipo que busca más control escribiendo todo. En cualquier caso, una ventanilla única que compare la sintaxis básica puede ser un salvavidas.

Si te gusta este artículo, no dudes en compartirlo en tus redes sociales favoritas.

Feliz codificación a todos.