Comandos básicos de SQL

Indice del Articulo

• Lista de comandos SQL para Sql Server y MySQL
• Curso de SQL Server Desde Cero
• Comandos sql para manipular Datos
• Clausulas básicas
• Conceptos básicos de base de datos
• Comandos básicos de SQL
• 
  

 Al momento de crear y administrar Bases de Datos con código SQL necesitamos hacer uso de comandos para acceder y manipular datos, por lo tanto, es necesario conocer y estudiar dichas instrucciones, ya que serán la base para que aprendamos código SQL y por consiguiente aprendamos la implementación de las operaciones básicas de Sql es decir: crear, actualizar, eliminar y manipular las bases de datos en Sql Server o MySQL.

SQL (Structured Query Language) es un lenguaje de programación utilizado para gestionar y manipular bases de datos relacionales.

Lista de comandos SQL para Sql Server y MySQL

A continuación veremos los principales comandos SQL utilizados durante la administración de las Bases de Datos y conocerás para qué sirven:

• SELECT: Se utiliza para recuperar datos de una tabla o vista.
• INSERT: Permite agregar nuevos registros a una tabla.
• UPDATE: Utilizado para modificar registros existentes en una tabla.
• DELETE: Sirve para eliminar registros de una tabla que cumplan ciertas condiciones.
• CREATE TABLE: Crea una nueva tabla en la base de datos, especificando las columnas y sus tipos de datos.
• ALTER TABLE: Modifica una tabla existente, permitiendo agregar, modificar o eliminar columnas.
• DROP TABLE: Elimina una tabla y todos sus datos de la base de datos de forma permanente.
• CREATE DATABASE: Crea una nueva base de datos en el servidor de bases de datos.
• USE DATABASE: Selecciona una base de datos específica para trabajar en ella.
• ORDER BY: Se utiliza para ordenar los resultados de una consulta en función de una o más columnas.
• GROUP BY: Agrupa filas basadas en los valores de una columna y se utiliza comúnmente con funciones de agregación como COUNT, SUM, AVG, etc.
• JOIN: Combina filas de dos o más tablas basadas en una columna común.
• WHERE: Se utiliza para aplicar condiciones a las filas que se seleccionarán en una consulta.
• AND, OR: Operadores lógicos utilizados en combinación con la cláusula WHERE para crear condiciones más complejas.
• ORDER BY: Se utiliza para ordenar los resultados de una consulta en función de una o más columnas, ya sea de manera ascendente o descendente.
• LIMIT: Limita el número de filas recuperadas en una consulta.
• DISTINCT: Se utiliza para eliminar duplicados de los resultados de una consulta.
• HAVING: Funciona como una extensión de GROUP BY y se utiliza para filtrar grupos basados en condiciones de agregación.
• UNION: Combina los resultados de dos o más consultas en un solo conjunto de resultados.
• CREATE INDEX: Crea un índice en una o más columnas de una tabla para mejorar la velocidad de las consultas.
• DROP INDEX: Elimina un índice de una tabla.
• GRANT: Concede privilegios o permisos a usuarios en la base de datos.
• REVOKE: Revoca privilegios previamente concedidos a usuarios en la base de datos.
• TRANSACTION: Inicia, confirma o deshace una transacción en la base de datos.
• COMMIT: Confirma una transacción, guardando los cambios en la base de datos.
• ROLLBACK: Deshace una transacción, revirtiendo los cambios no confirmados.

Comandos sql para manipular Datos

SELECT es utilizado para recuperar datos de una o más tablas, en otras palabras, nos permite hacer consultas de los registros de las tablas.

INSERT es utilizado añadir o insertar registros a una tabla creada previamente, su complemento es Insert into.

UPDATE es utilizado para modificar los datos de un conjunto de registros existentes en una tabla

DELETE es utilizado para eliminar o borrar todo o una parte de los datos de la tabla indicada por el argumento especificado después de la palabra clave FROM.

TRUNCATE es utilizado para borrar todos los registros de una tabla, pero no la tabla, es decir que quedaría una tabla vacía.

Clausulas básicas

Las cláusulas son condiciones y las utilizamos para especificar los datos que deseamos seleccionar o manipular.

FROM se utiliza para especificar la tabla de la cual se van a consultar los registros

GROUP BY se utiliza para separar en grupos específicos los registros consultados.

ORDER BY  se utiliza para ordenar los registros seleccionados tomando en cuenta los parámetros que le indiquemos.

WHERE Se utilizar para determinar los registros seleccionados con la cláusula FROM

HAVING es parecida a WHERE, ya que determina qué registros se seleccionan. Cuando los registros se han agrupado utilizando GROUP BY, la cláusula HAVING determina cuáles de ellos se van a mostrar.

Comandos para la cláusula Select

AVG Se utiliza para determinar el promedio de los registros de un campo determinado, en una tabla especifica.

COUNT Se utiliza para devolver el número de registros que se muestran en una consulta realizada.

SUM Se utiliza para devolver la suma de todos los registros de un campo especifico, dentro de una tabla.

MAX Se utiliza para devolver el registro mayor o cantidad mayor de un campo especifico, dentro de una tabla.

MIN Se utiliza para devolver el registro menor o cantidad menor de un campo especifico, dentro de una tabla.

Todos las instrucciones sql vistas anteriormente son los mas usados, sin embargo es importante tener claro que deben ser complementados con ciertas palabras reservadas, por lo tanto es importante conocer la sintaxis para cada una de las acciones que deseamos realizar en nuestra Base de Datos. Te invito a que continúes aprendiendo en las diferentes categorías de este sitio web

Investiga  

Índice para evaluación 

Definiciones de base de datos

Que es un Registro en Base de Datos

Que es un campo en Base de Datos

Que es una llave primaria en Base de Datos

Que es un atributo en Base de Datos

Que es una entidad en Base de Datos

Relaciones en Base de Datos

Modelo relacional en Base de Datos

Modelo entidad relación en Base de Datos

Que es una consulta en Base de Datos

Que es un dato en base de datos

Qué es una llave foránea en base de datos

Tipos de datos en base de datos

Que es un formulario en base de datos

Que es un informe en base de datos

Que es una transacción en base de datos

https://www.ajpdsoft.com/modules.php?name=News&file=print&sid=629

Creación de una base de datos de grafos y ejecución de algunas consultas de coincidencia de patrones mediante T-SQL

 

Esquema de ejemplo:

En este ejemplo se crea un esquema de gráfico para una red social hipotética que tiene Peoplenodos y RestaurantCity . Estos nodos se conectan entre sí mediante Friendsbordes , LivesInLikesy LocatedIn . En el diagrama siguiente se muestra un esquema de ejemplo con restaurantbordes , city, person nodos y LivesIn, LocatedIn. Likes




Script de ejemplo

El siguiente script de ejemplo usa la nueva sintaxis de T-SQL para crear tablas perimetrales y de nodo. Obtenga información sobre cómo insertar datos en tablas perimetrales y de nodo mediante INSERT la instrucción y también muestra cómo usar MATCH la cláusula para la coincidencia de patrones y la navegación.

Este script realiza los pasos siguientes:

1. Cree una base de datos denominada GraphDemo.
2. Crear tablas de nodo.
3. Crear tablas perimetrales.

    CREATE DATABASE GraphDemo;

USE GraphDemo;

-- Create NODE tables

CREATE TABLE Person (

  ID INTEGER PRIMARY KEY,

  name VARCHAR(100)

) AS NODE;

CREATE TABLE Restaurant (

  ID INTEGER NOT NULL,

  name VARCHAR(100),

  city VARCHAR(100)

) AS NODE;

CREATE TABLE City (

  ID INTEGER PRIMARY KEY,

  name VARCHAR(100),

  stateName VARCHAR(100)

) AS NODE;

-- Create EDGE tables.

CREATE TABLE likes (rating INTEGER) AS EDGE;

CREATE TABLE friendOf AS EDGE;

CREATE TABLE livesIn AS EDGE;

CREATE TABLE locatedIn AS EDGE;




Ahora, insertaremos datos para representar las relaciones.

1. Insertar datos en tablas de nodo.
   1. La inserción en una tabla de nodos es la misma que la inserción en una tabla normal.
2. Inserte datos en tablas perimetrales, en este caso, para los que cada persona quiera en el likes perímetro.
   1. Al insertar en una tabla perimetral, proporcione las $node_id columnas from $from_id y $to_id .
3. Inserte datos en el livesIn perímetro para asociar personas a la ciudad donde viven.
4. Inserte datos en el locatedIn perímetro para asociar restaurantes a la ciudad donde se encuentran.
5. Inserte datos en el friendOf borde a los amigos asociados.

-- Insert data into node tables. Inserting into a node table is same as inserting into a regular table

INSERT INTO Person (ID, name)

    VALUES (1, 'John')

         , (2, 'Mary')

         , (3, 'Alice')

         , (4, 'Jacob')

         , (5, 'Julie');

INSERT INTO Restaurant (ID, name, city)

    VALUES (1, 'Taco Dell','Bellevue')

         , (2, 'Ginger and Spice','Seattle')

         , (3, 'Noodle Land', 'Redmond');

INSERT INTO City (ID, name, stateName)

    VALUES (1,'Bellevue','WA')

         , (2,'Seattle','WA')

         , (3,'Redmond','WA');

-- Insert into edge table. While inserting into an edge table,

-- you need to provide the $node_id from $from_id and $to_id columns.

--/* Insert which restaurants each person likes */

INSERT INTO likes

    VALUES ((SELECT $node_id FROM Person WHERE ID = 1), (SELECT $node_id FROM Restaurant WHERE ID = 1), 9)

         , ((SELECT $node_id FROM Person WHERE ID = 2), (SELECT $node_id FROM Restaurant WHERE ID = 2), 9)

         , ((SELECT $node_id FROM Person WHERE ID = 3), (SELECT $node_id FROM Restaurant WHERE ID = 3), 9)

         , ((SELECT $node_id FROM Person WHERE ID = 4), (SELECT $node_id FROM Restaurant WHERE ID = 3), 9)

         , ((SELECT $node_id FROM Person WHERE ID = 5), (SELECT $node_id FROM Restaurant WHERE ID = 3), 9);

--/* Associate in which city live each person*/

INSERT INTO livesIn

    VALUES ((SELECT $node_id FROM Person WHERE ID = 1), (SELECT $node_id FROM City WHERE ID = 1))

         , ((SELECT $node_id FROM Person WHERE ID = 2), (SELECT $node_id FROM City WHERE ID = 2))

         , ((SELECT $node_id FROM Person WHERE ID = 3), (SELECT $node_id FROM City WHERE ID = 3))

         , ((SELECT $node_id FROM Person WHERE ID = 4), (SELECT $node_id FROM City WHERE ID = 3))

         , ((SELECT $node_id FROM Person WHERE ID = 5), (SELECT $node_id FROM City WHERE ID = 1));

--/* Insert data where the restaurants are located */

INSERT INTO locatedIn

    VALUES ((SELECT $node_id FROM Restaurant WHERE ID = 1), (SELECT $node_id FROM City WHERE ID =1))

         , ((SELECT $node_id FROM Restaurant WHERE ID = 2), (SELECT $node_id FROM City WHERE ID =2))

         , ((SELECT $node_id FROM Restaurant WHERE ID = 3), (SELECT $node_id FROM City WHERE ID =3));

--/* Insert data into the friendOf edge */

INSERT INTO friendOf

    VALUES ((SELECT $NODE_ID FROM Person WHERE ID = 1), (SELECT $NODE_ID FROM Person WHERE ID = 2))

         , ((SELECT $NODE_ID FROM Person WHERE ID = 2), (SELECT $NODE_ID FROM Person WHERE ID = 3))

         , ((SELECT $NODE_ID FROM Person WHERE ID = 3), (SELECT $NODE_ID FROM Person WHERE ID = 1))

         , ((SELECT $NODE_ID FROM Person WHERE ID = 4), (SELECT $NODE_ID FROM Person WHERE ID = 2))

         , ((SELECT $NODE_ID FROM Person WHERE ID = 5), (SELECT $NODE_ID FROM Person WHERE ID = 4));

A continuación, consultaremos los datos para buscar información de los datos.

1. Use la función MATCH del grafo para buscar qué restaurantes le gusta John.
2. Encuentra los restaurantes a los que le gustan los amigos de John.
3. Encuentra gente que le gusta un restaurante en la misma ciudad en la que viven.

-- Find Restaurants that John likes

SELECT Restaurant.name

FROM Person, likes, Restaurant

WHERE MATCH (Person-(likes)->Restaurant)

AND Person.name = 'John';

-- Find Restaurants that John's friends like

SELECT Restaurant.name

FROM Person person1, Person person2, likes, friendOf, Restaurant

WHERE MATCH(person1-(friendOf)->person2-(likes)->Restaurant)

AND person1.name='John';

-- Find people who like a restaurant in the same city they live in

SELECT Person.name

FROM Person, likes, Restaurant, livesIn, City, locatedIn

WHERE MATCH (Person-(likes)->Restaurant-(locatedIn)->City AND Person-(livesIn)->City);

Por último, una consulta más avanzada busca a los amigos de amigos. Esta consulta excluye los casos en los que la relación "vuelve a bucles". Por ejemplo, Alice es amiga de John; Juan es amigo de María; y Mary a su vez es amiga de Alice. Esto hace que un "bucle" vuelva a Alice. En muchos casos, es necesario comprobar explícitamente estos bucles y excluir los resultados.

-- Find friends-of-friends-of-friends, excluding those cases where the relationship "loops back".

-- For example, Alice is a friend of John; John is a friend of Mary; and Mary in turn is a friend of Alice.

-- This causes a "loop" back to Alice. In many cases, it is necessary to explicitly check for such loops and exclude the results.

SELECT CONCAT(Person.name, '->', Person2.name, '->', Person3.name, '->', Person4.name)

FROM Person, friendOf, Person as Person2, friendOf as friendOffriend, Person as Person3, friendOf as friendOffriendOfFriend, Person as Person4

WHERE MATCH (Person-(friendOf)->Person2-(friendOffriend)->Person3-(friendOffriendOfFriend)->Person4)

AND Person2.name != Person.name

AND Person3.name != Person2.name

AND Person4.name != Person3.name

AND Person.name != Person4.name;

Limpieza

Limpie el esquema y la base de datos creados para el ejemplo en SQL Server. Recuerda que se eliminaran los datos de las tablas

USE graphdemo;

DROP TABLE IF EXISTS likes;

DROP TABLE IF EXISTS Person;

DROP TABLE IF EXISTS Restaurant;

DROP TABLE IF EXISTS City;

DROP TABLE IF EXISTS friendOf;

DROP TABLE IF EXISTS livesIn;

DROP TABLE IF EXISTS locatedIn;

--Limpie el esquema y la base de datos creados para el ejemplo en Azure SQL Database.

--Connect to the graphdemo database

DROP TABLE IF EXISTS likes;

DROP TABLE IF EXISTS Person;

DROP TABLE IF EXISTS Restaurant;

DROP TABLE IF EXISTS City;

DROP TABLE IF EXISTS friendOf;

DROP TABLE IF EXISTS livesIn;

DROP TABLE IF EXISTS locatedIn;

--Connect to the  database

DROP DATABASE graphdemo;