Dentro de este artículo:
- Definiciones
- SELECT FROM
- SELECT DISTINCT FROM
- WHERE
- WHERE AND/OR
- WHERE IN
- WHERE BETWEEN
- WHERE LIKE
- ORDER BY
- SQL Funciones
- SELECT SUM(Sales) FROM Store_Information;
- GROUP BY
- HAVING
- USO DE ALIAS EN (TABLAS)
- JOIN
- OUTER JOIN
- LEFT OUTER JOIN
- RIGHT OUTER JOIN
- FULL OUTER JOIN
- UNION
- SELECT INTO
- INSERT INTO SELECT
- CREATE DATABASE
- CREATE TABLE
- Constraints (Create)
- NOT NULL Constraint
- UNIQUE Constraint
- PRIMARY KEY Constraint
- CREATE INDEX
- DROP INDEX, DROP TABLE, and DROP DATABASE
- ALTER TABLE Statement
- AUTO INCREMENT Field
- CREATE VIEW
- NULL Values
- GROUP BY
- HAVING Clause
- Insertar Comentarios
- Caso práctico para determinar los costos usando SQL.
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.
- Oracle
- MySQL
- Microsoft SQL Server
- PostgreSQL
- MongoDB
- DB2 (IBM)
- Cassandra
- Microsoft Access
- SQLite
- 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.

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.

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.

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).

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

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
Contenido relacionado