SQL (Structured Query Language)

SQL (Structured Query Language)

SQL (Structured Query Language) es un lenguaje de programación estándar e interactivo para la obtención de información desde una base de datos y para actualizarla. Aunque SQL es a la vez un ANSI y una norma ISO, muchos productos de bases de datos soportan SQL con extensiones propietarias al lenguaje estándar. Las consultas toman la forma de un lenguaje de comandos que permite seleccionar, insertar, actualizar, averiguar la ubicación de los datos, y más. También hay una interfaz de programación.

Las bases de datos más populares que manejan SQL son las siguientes.

  1. Oracle
  2. MySQL
  3. Microsoft SQL Server
  4. PostgreSQL
  5. MongoDB
  6. DB2 (IBM)
  7. Cassandra
  8. Microsoft Access
  9. SQLite
  10. Redis

Definiciones

  • Campo: Espacio para vaciar datos (Números, Fechas, Caracteres).
  • Registros: Conjunto de Campos que tienen relación entre sí.
  • Tabla: (Campos x Registros).
  • Base de Datos: Conjunto de Tablas y relaciones entre ellas.
  • Campos: Fecha, precios, movimientos, tipos, Items, descripciones, nombres.
  • Registros: Lineas de facturas, Items, Movimientos de Almacen.
  • Tablas: BOM’s, Movimientos, AP, AR, BOM’s, Item Master, SO, PO, Costos.
  • Bases de Datos: Empresas, Plantas, Regiones, CEDI’s.

SELECT FROM

Selecciona los campos elegidos de una tabla, o “*” para todos.

Select [plant],[item],[fecha]

,[precio]

,[cantidad]

,[proveedor]

From [db].[recibos]

Select * From [db].[recibos]

SELECT DISTINCT FROM

Si la tabla solo tiene campos repetidos, solo selecciona los que son diferentes.

Select Distinct [plant]

,[Item]

,[proveedor]

From [db].[recibos]

WHERE

SELECT “nombre_columna”

FROM “nombre_tabla”

WHERE “condición”;

SELECT Store_Name

FROM Store_Information

WHERE Sales > 1000;

WHERE AND/OR

SELECT “nombre_columna”

FROM “nombre_tabla”

WHERE “condición simple”

{[AND|OR] “condición simple”}+;

SELECT Store_Name

FROM Store_Information

WHERE Sales > 1000

OR (Sales < 500 AND Sales > 275);

WHERE IN

SELECT “nombre_columna”

FROM “nombre_tabla”

WHERE “nombre_columna” IN (‘’valor1’, ‘’valor2’, …);

SELECT *

FROM Store_Information

WHERE Store_Name IN (‘Los Angeles’, ‘San Diego’);

WHERE BETWEEN

SELECT “nombre_columna”

FROM “nombre_tabla”

WHERE “nombre_columna” BETWEEN ‘valor1’ AND ‘valor2’;

SELECT *

FROM Store_Information

WHERE Txn_Date BETWEEN ‘06-Jan-1999’ AND ‘10-Jan-1999’;

WHERE LIKE

SELECT “nombre_columna”

FROM “nombre_tabla”

WHERE “nombre_columna” LIKE {patrón}; SELECT *

FROM Store_Information

WHERE Store_Name LIKE ‘%AN%’;

ORDER BY

SELECT “nombre_columna”

FROM “nombre_tabla” [WHERE “condición”]

ORDER BY “nombre_columna” [ASC, DESC];

SELECT Store_Name, Sales, Txn_Date

FROM Store_Information

ORDER BY Sales DESC;

SQL Funciones

AVG (Campo)

COUNT (Campo)

MAX (Campo)

MIN (Campo)

SUM (Campo)

SELECT SUM(Sales) FROM Store_Information;

COUNT

SELECT COUNT (Store_Name)

FROM Store_Information; SELECT COUNT (Store_Name) FROM Store_Information;

SELECT COUNT (DISTINCT Store_Name)

FROM Store_Information;

GROUP BY

SELECT “nombre1_columna”, SUM(“nombre2_columna”)

FROM “nombre_tabla”

GROUP BY “nombre1-columna”;

SELECT Store_Name, SUM(Sales)

FROM Store_Information

GROUP BY Store_Name;

HAVING

En vez de utilizar la cláusula WHERE en la instrucción SQL, a pesar de que necesitemos utilizar la cláusula HAVING, que se reserva para funciones de agregados. La cláusula HAVING se coloca generalmente cerca del fin de la instrucción SQL, y la instrucción SQL con la cláusula HAVING. puede o no incluir la cláusula GROUP BY sintaxis para HAVING es,

SELECT “nombre1_columna”, SUM(“nombre2_columna”)

FROM “nombre_tabla”

GROUP BY “nombre1_columna”

HAVING (condición de función aritmética);

SELECT Store_Name, SUM(Sales)

FROM Store_Information

GROUP BY Store_Name HAVING SUM(Sales) > 1500;

USO DE ALIAS EN (TABLAS)

Resumiendo, los alias de columna existen para ayudar en la organización del resultado. En el ejemplo anterior, cualquiera sea el momento en que vemos las ventas totales, se enumeran

como SUM(Sales). Mientras esto es comprensible, podemos ver casos donde el título de la columna pueden complicarse (especialmente si incluye varias operaciones aritméticas). El uso de un alias de columna haría el resultado mucho más legible.

El segundo tipo de alias es el alias de tabla. Esto se alcanza al colocar un alias directamente luego del nombre de tabla en la cláusula FROM. Esto es conveniente cuando desea obtener información de dos tablas separadas (el término técnico es ‘realizar uniones’). La ventaja de utiliza un alias de tablas cuando realizamos uniones es rápidamente aparente cuando hablamos de uniones.

SELECT “alias_tabla”.”nombre1_columna” “alias_columna”

FROM “nombre_tabla” “alias_tabla”;

SELECT A1.Store_Name Store, SUM(A1.Sales) “Total Sales”

FROM Store_Information A1 GROUP BY A1.Store_Name;

JOIN

Unión de tablas por parámetros.

  • INNER JOIN: Regresa todos los registros que coincidan en las dos tablas.
  • LEFT JOIN: Regresa todos los registros que coincidan en la tabla de la derecha.
  • RIGHT JOIN: Regresa todos los registros que coincidan en la tabla de la izquierda.FULL
  • JOIN: Regresa todos los registros cuando cuando coincidan en alguna de las tablas.
JOIN Unión de tablas por parámetros

OUTER JOIN

SELECT column_name(s)

FROM table1

INNER JOIN table2

ON table1.column_name=table2.column_name;

LEFT OUTER JOIN

SELECT column_name(s)

FROM table1

LEFT OUTER JOIN table2

ON able1.column_name=table2.column_name;

RIGHT OUTER JOIN

SELECT column_name(s)

FROM table1

RIGHT OUTER JOIN table2

ON table1.column_name=table2.column_name;

FULL OUTER JOIN

SELECT column_name(s)

FROM table1

FULL OUTER JOIN table2

ON table1.column_name=table2.column_name;

UNION

SELECT column_name(s) FROM table1

UNION

SELECT column_name(s) FROM table2;

Union, es solo para datos distintos. SELECT column_name(s) FROM table1 UNION ALL

SELECT column_name(s) FROM table2;

Union ALL, Pega tal cual las dos tablas.

Función Join

SELECT INTO

Copia los datos de una tabla y los inserta en otra. SELECT column_name(s)

INTO newtable [IN externaldb] FROM table1;

SELECT *

INTO CustomersBackup2013 FROM Customers;

SELECT *

INTO CustomersBackup2013 IN ‘Backup.mdb’

FROM Customers;

INSERT INTO SELECT

Copia datos de una tabla y la inserta en otra ya existente. INSERT INTO table2

SELECT * FROM table1; INSERT INTO table2 (column_name(s)) SELECT column_name(s) FROM table1;

CREATE DATABASE

Crea una base de datos. CREATE DATABASE dbname; CREATE DATABASE my_db;

CREATE TABLE

Crea una tabla en una base de datos.

CREATE TABLE table_name

(

column_name1 data_type(size), column_name2 data_type(size), column_name3 data_type(size),

….

);

Constraints (Create)

Crea reglas en la base de datos en una tabla.

NOT NULL – La columna no puede quedar en blanco.

UNIQUE – Cada registro tiene que tener un valor único, no repetido.

PRIMARY KEY – agrega un indice a los registros para hacer más fácil su acceso.

FOREIGN KEY – Referencia dos indices de dos tablas.

CHECK – Crea una condición para una columan especifica.

DEFAULT – Crea un valor por default en una columna.

CREATE TABLE table_name

(column_name1 data_type(size) constraint_name, column_name2 data_type(size) constraint_name, column_name3 data_type(size) constraint_name,

);

NOT NULL Constraint

Restricción de que el valor del campo no puede ser Nulo (nada).

CREATE TABLE PersonsNotNull (

P_Id int NOT NULL,

LastName varchar(255) NOT NULL, FirstName varchar(255),

Address varchar(255), City varchar(255)

)

UNIQUE Constraint

  • Identificador unico de registros.
    • Generalmente se usa con el Primary key (indexado).

CREATE TABLE Persons (

P_Id int NOT NULL,

LastName varchar(255) NOT NULL, FirstName varchar(255),

Address varchar(255), City varchar(255),

CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName)

)

  • Si la tabla ya esta creada se usa ALTER TABLE Persons

ADD UNIQUE (P_Id)

ALTER TABLE Persons

ADD CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName)

PRIMARY KEY Constraint

Identifica cada registro en la base de datos. Debe de contener datos unicos y no Nulos. Solo se puede crear una clave primaria.

CREATE TABLE Persons (

P_Id int NOT NULL PRIMARY KEY,

LastName varchar(255) NOT NULL, FirstName varchar(255),

Address varchar(255), City varchar(255)

)

CREATE INDEX

Crea un índice en la tabla. CREATE INDEX index_name ON table_name (column_name)

CREATE UNIQUE INDEX index_name ON table_name (column_name) CREATE INDEX PIndex

ON Persons (LastName) CREATE INDEX PIndex

ON Persons (LastName, FirstName)

DROP INDEX, DROP TABLE, and DROP DATABASE

Borra el Indice.

DROP INDEX table_name.index_name

Borra la tabla o base de datos. DROP TABLE table_name

DROP DATABASE database_name

Borra los datos de la tabla, pero no la table en si.

TRUNCATE TABLE table_name

ALTER TABLE Statement

ALTER TABLE es usado para agreagar, borrar, o/i modificar campos en una base de datos

existente.

Agregar

ALTER TABLE table_name ADD column_name datatype ALTER TABLE table_name DROP COLUMN column_name ALTER TABLE table_name

ALTER COLUMN column_name datatype

AUTO INCREMENT Field

Se usa mucho para agregar un valor incremental en la clave primaria.

CREATE TABLE Persons (

ID int IDENTITY(1,1) PRIMARY KEY,

LastName varchar(255) NOT NULL, FirstName varchar(255),

Address varchar(255), City varchar(255)

)

CREATE VIEW

Es una base de datos virtual temporal en base a una consulta. CREATE VIEW view_name AS

SELECT column_name(s) FROM table_name WHERE condition

CREATE VIEW [Category Sales For 1997] AS

SELECT DISTINCT CategoryName,Sum(ProductSales) AS CategorySales FROM [Product Sales for 1997]

GROUP BY CategoryName

NULL Values

Representa un valor que no se tiene.

SELECT LastName,FirstName,Address FROM Persons WHERE Address IS NULL

SELECT LastName,FirstName,Address FROM Persons WHERE Address IS NOT NULL

GROUP BY

Se usa junto con las funciones de agregado, como SUM(),MAX(), AVG(),MIN()

SELECT column_name, aggregate_function(column_name)

FROM table_name

WHERE column_name operator value GROUP BY column_name;

SELECT Shippers.ShipperName,COUNT(Orders.OrderID) AS NumberOfOrders FROM Orders LEFT JOIN Shippers

ON Orders.ShipperID=Shippers.ShipperID

GROUP BY ShipperName;

HAVING Clause

HAVING fue agregada al SQL porque el WHERE no puede ser usado con funciones de agregado.

SELECT column_name, aggregate_function(column_name)

FROM table_name

WHERE column_name operator value GROUP BY column_name

HAVING aggregate_function(column_name) operator value;

SELECT Employees.LastName, COUNT(Orders.OrderID) AS NumberOfOrders FROM (Orders INNER JOIN Employees

ON Orders.EmployeeID=Employees.EmployeeID)

GROUP BY LastName

HAVING COUNT(Orders.OrderID) > 10;

Insertar Comentarios

Comentarios de una linea se usa — y el comentatio.

De más de una linea. Se usa /* Aquí comenta. */

/*Select all the columns of all the records

in the Customers table:*/ SELECT * FROM Customers;

–SELECT * FROM Customers; SELECT * FROM Products;

Caso práctico para determinar los costos usando SQL.

En este caso práctico definiremos 3 periodos de tiempo en el inventario: OH (on hand), OPOR (on order) y Planned Qty (ordenes planeadas).

Dependiendo de esto tendremos 3 tipos de costos: el costo de los recibos para el OH o WAC, el costo de las ordenes abiertas o WAP y el costo de las ordenes planeadas, que usaremos el precio de la cotización o negociación (Award o EDI) según el ítem y proveedor.

Caso práctico para determinar los costos usando SQL

Con lo cual podemos definir las siguientes cláusulas de SQL para definir las combinaciones que tenemos según el periodo del MRP (OH, OO, Plan, NoData, y sus combinaciones).

Combinación de clausulas de SQL

En base a estas 7 categorías podemos definir cuál es el precio que debemos de tomar previamente calculado.

Definir cuál es el precio
Referencias y Práctica 
https://www.w3schools.com/sql/sql_quickref.asp 
http://www.1keydata.com/es/sql/ 
https://livesql.oracle.com/apex/livesql/file/index.html
Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *