Acompáñanos en este breve artículo y descubre los comandos útiles de Transact-SQL para la gestión de SQL Server, mediante los que podrás realizar tareas básicas con tus bases de datos a través del lenguaje Transact-SQL.
Antes de empezar, debes saber que este artículo está pensado para aquellos que están empezando con Transact-SQL o que tienen poca experiencia con él. Si es tu caso, creo que lo que aquí se cuenta puede ser de gran interés para ti, ya que te dará las primeras nociones que debes conocer para operar con bases de datos SQL Server mediante instrucciones o comandos SQL.
Lo primero que debemos saber es que una instrucción SQL es básicamente una unidad de trabajo atómica (no divisible) que, o bien terminará de manera correcta, o bien finalizará en un fallo que desencadenará una vuelta atrás (rollback).
Lo siguiente que debemos saber es que toda instrucción de SQL estará formada no solo por el propio comando, sino que además tendrá otras partes como parámetros, variables, etc.
NOTA: Este no pretende ser un manual completo de SQL para SQL Server, o lo que es lo mismo, de T-SQL (Transact-SQL), sino que pretende ser un pequeño punto de partida para su aprendizaje. Por esta razón, no se contemplan todas las opciones, pero si que se da una visión de muchas de ellas.
Tipos de instrucciones:
En SQL hay distintos tipos de instrucciones destinadas a hacer cosas tan dispares como definir datos, manipular datos o extraer datos. Usualmente se habla de tres tipos de instrucciones, las DDL, DML y DCL, pero en realidad tenemos más, las TCL y las DQL.
En nuestro caso, hablaremos de todas ellas en mayor o menor medida.
Los tipos de instrucciones existentes son:
- DDL: Instrucciones del lenguaje de definición de datos (Data Definition Language).
- DML: Instrucciones de lenguaje de manipulación de datos (Data Manipulation Language).
- DCL: Instrucciones de lenguaje de control de datos (Data Control Language).
- TCL: Instrucciones de lenguaje de control de transacciones (Transactional Control Language).
- DQL: Instrucciones de lenguaje de consulta de datos (Data Query Language).
En este punto, como no podría ser de otra manera, vamos a ir a hablando de cada uno de estos tipos de instrucciones del lenguaje SQL para ir aprendiendo sobre ellos. Para cada uno de los tipos, se hará una breve descripción de los comandos aquí definidos con sus usos, sintaxis y ejemplos.
DDL (Data Definition Language):
Los comandos de lenguaje de definición de datos, comúnmente conocidos como DDL, se utilizan tanto para crear como para modificar la estructura de los objetos de la base de datos.
Los comandos que podemos encontrar en este tipo son:
- CREATE: Este comando nos permite crear objetos dentro de la base de datos.
- ALTER: Este comando posibilita alterar objetos de la base de datos existente.
- DROP: Este comando permite eliminar objetos de la base de datos existente.
- TRUNCATE: Este comando elimina todos los registros de una tabla y restablece la identidad de la tabla al valor inicial, teniendo como resultado una especie de “reset”.
A continuación, vamos a revisar cada una de estas instrucciones.
CREATE:
El comando CREATE es el usado para la creación de objetos dentro de SQL, siendo posible crear bases de datos, tablas, etc.
Usualmente trabajaremos con la creación de tablas dentro de bases de datos existentes, pudiendo asignar infinidad de propiedades, campos, tipos de datos, etc.
La sintaxis reducida de CREATE TABLE sería algo similar a lo siguiente:
CREATE TABLE <TableName>
( { <column_definition> } [ ,… n ] );
Donde un ejemplo simple de creación de base de datos podría ser como el siguiente:
CREATE TABLE Clientes
(
ID smallint NOT NULL PRIMARY KEY
Nombre nmarchar(50)
Direccion nmarchar(200)
Telefono int
Mail nmarchar(40)
Contacto nmarchar(40)
Cuenta int NOT NULL
);
En el caso de la creación de bases de datos, se usará una sintaxis en la cual se deberá dar un destino para la misma, unos tamaños, etc.
ALTER:
De igual manera que CREATE permite la creación de objetos dentro de nuestra base de datos o incluso la creación de la propia base de datos, el comando ALTER posibilita su modificación (alteración). Es decir, cambiar la definición de la tabla, pudiéndose hacer añadidos o eliminación en las columnas o creación de restricciones.
Usualmente trabajaremos con ALTER TABLE, que permite modificar las características de las tablas creadas previamente.
En el caso de ALTER TABLE hay que decir asimismo que no tienen la misma sintaxis en caso de tratarse de tablas basadas en disco y basadas en memoria.
DROP:
El comando DROP permite eliminar distintos objetos de las bases de datos, como por ejemplo bases de datos, tablas, vistas, etc. En el caso de DROP TABLE, cuando se ejecuta, este eliminará tanto la definición de la tabla como los datos contenidos en ella, restricciones, etc.
NOTA: Las Vistas y procedimientos de una tabla se deben eliminar explícitamente usando los comandos DROP VIEW o DROP PROCEDURE.
La sintaxis de este comando para la eliminación de una tabla será:
DROP TABLE [IF EXISTS] <TableName>;
Un ejemplo de uso sería:
DROP TABLE IF EXISTS Clientes;
TRUNCATE:
La instrucción TRUNCATE elimina todas las filas de una tabla, o en su caso las particiones especificadas de una tabla, haciendo de esta manera una eliminación una a una de todas las filas.
El comando TRUNCATE TABLE es muy similar al comando DELETE cuando no usa la cláusula de modificación WHERE. La ventaja que aporta TRUNCATE TABLE es que es mucho más rápida y más ligera, o lo que es lo mismo, conlleva el uso de menos recursos.
La sintaxis de TRUNCATE es:
TRUNCATE TABLE <TableName>;
Un ejemplo de este comando sería:
TRUNCATE TABLE Clientes;
DML (Data Manipulation Language):
Los comandos de lenguaje de manipulación de datos nos permiten recuperar, almacenar, modificar, eliminar, insertar y actualizar los datos que pueblan nuestra base de datos.
Los comandos más importantes son:
- SELECT: Permite recuperar los datos de una tabla, permitiendo así mismo hacer selección de las partes de estas tablas que se quieran mediante el uso de filtros y otras opciones.
- INSERT: Permite la inserción de nuevos datos en una tabla existente, tanto para la población de la misma como para la adición de nuevos registros en una tabla ya poblada.
- UPDATE: Permite actualizar los datos existentes en una tabla previamente rellenada.
- DELETE: Permite elimina todos los registros de una tabla existente.
Vamos a hablar de cada uno de estos comandos (instrucciones) para posibilitar que el lector pueda dar sus primeros pasos con ellos.
SELECT:
El comando SELECT es el más ampliamente usado en el mundo de SQL ya que es la instrucción usada para la extracción de información de la información albergada en la base de datos.
La instrucción SELECT, al ser una consulta, permite mostrar solo aquellas entradas o campos que nos interesen. Para ello se deberá hacer uso de dos opciones distintas.
La sintaxis del comando SELECT tiene la siguiente forma:
SELECT <Options> FROM <TableName>;
Algunos ejemplos de esta ejecución podrían ser:
SELECT * FROM Clientes;
Por un lado, se podrá hacer la consulta de todos los campos (las columnas) de la tabla haciendo uso del “SELECT *”, que mostrará todas las columnas contenidas en la tabla o, si se quiere, se podrá hacer un filtrado solo de las columnas que nos interesen, usando para ello los nombres de las columnas separadas por comas (,).
Un ejemplo de esto podría ser:
SELECT ID, Nombre, Contacto FROM Clientes;
Por otro lado, se podrá usar la clausula WHERE que permite filtrar para mostrar únicamente los campos que cumplan con un criterio concreto, como por ejemplo aquellos clientes que sean de un determinado sector.
La sintaxis del comando SELECT con la cláusula WHERE tiene la siguiente forma:
SELECT <Options> FROM <TableName>
WHERE <Conditions>;
Un ejemplo de esta ejecución podría ser:
SELECT ID, Nombre, Contacto FROM Clientes
WHERE Sector = ‘Reseller’;
NOTA: Siendo SELECT la instrucción o comando con la que más usualmente nos tocará trabajar, destinaremos un artículo a hablar sobre el en profundidad, viendo distintas opciones e infinidad de ejemplos.
INSERT:
La instrucción INSERT, que nos permite hacer carga de datos en una tabla, añadiendo información en filas adicionales existentes.
La sintaxis de este comando es la siguiente:
INSERT INTO <TableName> [(column1, column2,…columnN)]
VALUES (value1, value2,…valueN);
Donde los campos “columnX” hacen referencia a las columnas sobre las que se insertarán los datos y “valueX” hacen referencia a los datos con los que se cargarán dichas columnas.
Un ejemplo de INSERT puede ser algo similar a:
INSERT INTO Clientes (ID, Nombre, Direccion, Telefono, Mail, Contacto, Cuenta)
VALUES (723, Jotelulu, Plaza Pablo Ruiz Picasso 28020 Madrid, 911333712, Manuel Perez, 723723723723);
Si se insertan datos en todos los campos no será necesario especificar el nombre del campo, pudiéndose usar la siguiente sintaxis simplificada:
INSERT INTO <TableName>
VALUES (value1, value2, …, valueN);
Un ejemplo de esto podría ser:
INSERT INTO Clientes
VALUES (723, Jotelulu, Plaza Pablo Ruiz Picasso 28020 Madrid, 911333712, Manuel Perez, 723723723723);
UPDATE:
Tal como hemos dicho previamente, el comando UPDATE permite realizar actualizaciones o cambios dentro de una tabla, sustituyendo o cambiando datos existentes.
Este comando funciona en base a una condición definida mediante la cláusula WHERE. Una vez filtrado, se usa la cláusula SET para indicar los datos que se quieren modificar.
El comando UPDATE es un comando muy destructivo si se usa sin el debido cuidado. Suele usarse junto a la clausula WHERE para hacer un filtrado y seleccionar las filas a cambiar. Si no se filtra correctamente o se obvia ese filtrado, se pueden destruir todos los datos contenidos.
La sintaxis del comando UPDATE tiene la siguiente forma:
UPDATE <TableName>
SET
<ColumnName> = { expression | DEFAULT | NULL }
{,…n}
WHERE <search_conditions>;
Un ejemplo de este comando sería:
UPDATE Clientes
SET Contacto = ‘Manuel Perez’
WHERE ID = 73;
DELETE:
El comando DELETE nos permite eliminar un conjunto de filas, seleccionado las afectadas a través de una cláusula WHERE, estableciendo en ella una condición para su correcta selección. En caso de no establecerse la cláusula WHERE, se eliminarían todas las entradas de la tabla, dejándola en blanco.
Hay que decir que la cláusula WHERE de una instrucción DELETE tiene igual estructura a las cláusulas WHERE usadas en los comandos SELECT.
El código para la sentencia en caso de querer borrar toda la tabla sería:
DELETE [FROM] <TableName>;
Mientras que en caso
DELETE [FROM] <TableName>
WHERE <Condiciones>;
Un ejemplo de uso de la instrucción DELETE podría ser:
DELETE FROM Clientes
WHERE ID = 123;
DCL (Data Control Language):
Los comandos de lenguaje de control de datos, también conocidos como DCL, se utiliza para la gestión de accesos, para lo cual, nos permitirán crear roles, asignara permisos e integridades referenciales. Mediante este control de los accesos a la base de datos conseguiremos asegurarla.
Los comandos DCL disponibles son:
- GRANT: Este comando permite otorgar privilegios de acceso de un usuario a la base de datos.
- REVOKE: Este comando permite retira o revocar los privilegios de acceso de un usuario a la base de datos que previamente han sido otorgados mediante el uso del comando GRANT.
- DENY: Este comando permite denegar privilegios de acceso a un usuario a la base de datos. Es por así decirlo, la antítesis del comando GRANT.
GRANT:
El comando GRANT de Transact-SQL concede permisos a un elemento que sea protegible mediante el uso de permisos de acceso/seguridad. Este garantiza o asigna permisos a un elemento en concreto con una estructura similar a:
GRANT permiso ON objeto TO usuario
La sintaxis del comando GRANT sería:
GRANT { ALL [ PRIVILEGES ] }
permission [ ( columnX)
[ ON [ class :: ] securable ] TO principal [ ,…n ]
[ WITH GRANT OPTION ] [ AS principal ] ;
Donde las clases son:
- LOGIN
- DATABASE
- OBJECT
- ROLE
- SCHEMA
- USER
Un ejemplo de uso de GRANT puede ser:
GRANT EXECUTE ON Cloud TO jioller;
REVOKE:
El comando REVOKE está diseñado para eliminar o revocar los permisos que se han asignado previamente con GRANT.
La sintaxis del comando es:
REVOKE [ GRANT OPTION FOR ]
{
[ ALL [ PRIVILEGES ] ]
permission [ ( columnX
}
[ ON [ class :: ] securable ]
{ TO | FROM } principalX
[ CASCADE] [ AS principal ];
Un ejemplo de revocación de acceso podría tener esta forma:
REVOKE SELECT ON SCHEMA :: Clientes TO Vendedores;
TCL (Transactional Control Language):
Los comandos de lenguaje de control transaccional, usualmente conocidos como TCL se utilizan para realizar la administración de las diferentes transacciones que ocurren dentro de una base de datos.
Los comandos de TCL son:
- COMMIT: Es el comando usado para guardar el trabajo realizado hasta el momento en las transacciones.
- ROLLBACK: El comando que permite la restauración de la base de datos, llevándola al estado previo a la ejecución de la última secuencia de comandos, o lo que es lo mismo, hasta el último comando COMMIT en las transacciones.
- SAVE TRANSACTION: Es el comando usado para establecer un punto de respaldo (guardado) dentro de una transacción.
Revisemos ahora como funciona cada uno de estos comandos.
COMMIT:
El comando COMMIT marca el final de una transacción cuando esta es correcta, bien sea explícita o implícitamente. Cuando se realiza un COMMIT, todas las modificaciones de los datos que estaban realizándose en esa transacción atómica pasan a ser remanentes en la base de datos. Cuando estos datos se hacen permanentes, se liberan los recursos que estaban manteniendo el histórico de transacciones.
La sintaxis del comando COMMIT se muestra a continuación:
COMMIT TRANSACTION [ transaction_name | @tran_name_variable ] ] [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ];
Y un ejemplo de uso de la instrucción COMMIT sería:
COMMIT TRANSACTION;
Y en este caso veríamos toda la transacción desde su inicio hasta su fin cuando este es correcto:
BEGIN TRANSACTION;
DELETE FROM Clientes WHERE ID = 13;
COMMIT TRANSACTION;
ROLLBACK:
El comando ROLLBACK es básicamente la antítesis de COMMIT. Si COMMIT no se ejecuta, o mejor dicho, si hay problemas en la ejecución de los comandos de la transacción, esta debe ser revertida.
El comando usado para revertir los cambios es ROLLBACK, que revierte una transacción explícita o implícita hasta el inicio de dicha transacción, o hasta un punto de control dentro de la transacción.
La instrucción ROLLBACK borrará todas las modificaciones de datos realizadas hasta el punto al que regresa, liberando además los recursos que mantiene la transacción.
Es importante remarcar que no se incluyen los cambios en variables locales o variables de tabla.
La sintaxis del comando ROLLBACK se muestra a continuación:
ROLLBACK TRANSACTION [ transaction_name | @tran_name_variable ];
Y un ejemplo de uso de la instrucción ROLLBACK sería:
ROLLBACK TRANSACTION;
Y en este caso veríamos toda la transacción desde su inicio hasta su fin cuando este es correcto:
BEGIN TRANSACTION @TransactionName
INSERT INTO ValueTable VALUES(1);
ROLLBACK TRANNSACTION @TransactionName;
Con esto terminaríamos el primer repaso de comandos útiles para SQL Server, que ya podemos decir que no va a ser el último, sino el primero de muchos en los que trataremos nuevos comandos e incluso algunos de los que hemos visto en mayor profundidad.
Conclusiones:
A lo largo de este artículo hemos presentado algunos comandos o instrucciones útiles de Transact-SQL, que podremos usarlos tanto para crear, como modificar o eliminar objetos dentro de SQL Server, presentando tanto una explicación superficial como su sintaxis y un ejemplo de uso.
Esperamos que este pequeño repaso sirva como primera toma de contacto para aquellos que quieran empezar a aprender sobre el lenguaje SQL para Microsoft SQL Server.
Para aquellos que quieran seguir aprendiendo sobre SQL y SQL Server, recomendamos visitar el siguiente enlace, donde podrán leer artículos relacionados con esta tecnología.
También puedes ampliar información consultando la documentación de Microsoft Learn.
¡Gracias por acompañarnos!
