SQL

Contenido
SQL - Inicio
SQL - Descripción general
SQL - Conceptos RDBMS
SQL - Bases de datos
SQL - Sintaxis
SQL - Tipos de datos
SQL - Operadores
SQL - Expresiones
SQL - Crear base de datos
SQL - Eliminar base de datos
SQL - Seleccionar base de datos
SQL - Crear tabla
SQL - Descartar tabla
SQL - Insertar consulta
SQL - Seleccionar consulta
SQL - Cláusula Where
SQL - Cláusulas AND & OR
SQL - Consulta de actualización
SQL - Eliminar consulta
SQL - Cláusula Like
SQL - Cláusula superior
SQL - Ordenar por
SQL - Agrupar por
SQL: palabra clave distinta
SQL - Resultados de clasificación
SQL avanzado
SQL - Restricciones
SQL: uso de combinaciones
SQL - Cláusula de uniones
SQL - Valores NULL
SQL: sintaxis de alias
SQL - Índices
SQL - Alterar comando
SQL - Truncar tabla
SQL: uso de vistas
SQL - Tener cláusula
SQL - Transacciones
SQL - Comodines
SQL - Funciones de fecha
SQL - Tablas temporales
SQL - Tablas de clonación
SQL - Subconsultas
SQL: uso de secuencias
SQL - Manejo de duplicados
Inyección SQL
SQL - Descripción general
SQL es un lenguaje para operar bases de datos; incluye la creación de bases
de datos, eliminación, recuperación de filas, modificación de filas, etc. SQL es
un lenguaje estándar ANSI (American National Standards Institute), pero hay
muchas versiones diferentes del lenguaje SQL.
¿Qué es el SQL?
SQL es el lenguaje de consulta estructurado, que es un lenguaje de
computadora para almacenar, manipular y recuperar datos almacenados en
una base de datos relacional.
SQL es el lenguaje estándar para el sistema de base de datos
relacional. Todos los sistemas de gestión de bases de datos relacionales
(RDMS) como MySQL, MS Access, Oracle, Sybase, Informix, Postgres y SQL
Server utilizan SQL como su lenguaje de base de datos estándar.
Además, están usando diferentes dialectos, como -
 MS SQL Server usando T-SQL,

 Oracle usando PL / SQL,
 La versión de MS Access de SQL se llama JET SQL (formato nativo), etc.
¿Por qué SQL?

SQL es muy popular porque ofrece las siguientes ventajas:
 Permite a los usuarios acceder a datos en los sistemas de gestión de bases de
datos relacionales.
 Permite a los usuarios describir los datos.
 Permite a los usuarios definir los datos en una base de datos y manipular esos
datos.
 Permite incrustar en otros idiomas utilizando módulos SQL, bibliotecas y
precompiladores.
 Permite a los usuarios crear y soltar bases de datos y tablas.
 Permite a los usuarios crear vistas, procedimientos almacenados, funciones en
una base de datos.
 Permite a los usuarios establecer permisos en tablas, procedimientos y vistas.
Una breve historia de SQL

 1970 - El Dr. Edgar F. "Ted" Codd de IBM es conocido como el padre de las bases
de datos relacionales. Describió un modelo relacional para bases de datos.
 1974 - Aparece el lenguaje de consulta estructurado.
 1978 - IBM trabajó para desarrollar las ideas de Codd y lanzó un producto llamado
System / R.
 1986 - IBM desarrolló el primer prototipo de base de datos relacional y
estandarizado por ANSI. La primera base de datos relacional fue lanzada por
Relational Software, que luego se conoció como Oracle.
Proceso SQL
Cuando está ejecutando un comando SQL para cualquier RDBMS, el sistema
determina la mejor manera de llevar a cabo su solicitud y el motor SQL
determina cómo interpretar la tarea.
Hay varios componentes incluidos en este proceso.
Estos componentes son -
 Despachador de consultas
 Motores de optimización
 Motor de consulta clásico
 Motor de consultas SQL, etc.
Un motor de consulta clásico maneja todas las consultas que no son SQL,
pero un motor de consulta SQL no maneja archivos lógicos.
El siguiente es un diagrama simple que muestra la arquitectura SQL:
www.postparaprogramadores.com
/
Comandos SQL
Los comandos SQL estándar para interactuar con bases de datos relacionales
son CREATE, SELECT, INSERT, UPDATE, DELETE y DROP. Estos
comandos se pueden clasificar en los siguientes grupos según su naturaleza:
DDL - Lenguaje de definición de datos
No Comando y descripción
Señor.
1 CREAR
Crea una nueva tabla, una vista de una tabla u otro objeto en la base de datos.
ALTERAR
2
Modifica un objeto de base de datos existente, como una tabla.
SOLTAR
3 Elimina una tabla completa, una vista de una tabla u otros objetos en la base de
datos.
DML - Lenguaje de manipulación de datos
Señor.
1 SELECCIONE
Recupera ciertos registros de una o más tablas.
INSERTAR
2
Crea un registro.
ACTUALIZAR
3
Modifica registros.
ELIMINAR
44
Borra registros.
DCL - Lenguaje de control de datos
Señor.
1 CONCEDER
Da un privilegio al usuario.
REVOCAR
2
Retira los privilegios otorgados por el usuario.
SQL - Conceptos RDBMS

¿Qué es el RDBMS?
RDBMS significa R elational D atabase M GESTIÓN S istema. RDBMS es la
base de SQL y de todos los sistemas de bases de datos modernos como MS
SQL Server, IBM DB2, Oracle, MySQL y Microsoft Access.
Un sistema de gestión de bases de datos relacionales (RDBMS) es un sistema
de gestión de bases de datos (DBMS) que se basa en el modelo relacional
introducido por EF Codd.
¿Qué es una mesa?

Los datos en un RDBMS se almacenan en objetos de base de datos que se
llaman tablas . Esta tabla es básicamente una colección de entradas de datos
relacionadas y consta de numerosas columnas y filas.
Recuerde, una tabla es la forma más común y más simple de almacenamiento
de datos en una base de datos relacional. El siguiente programa es un
ejemplo de una tabla CLIENTES:
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
¿Qué es un campo?
Cada tabla se divide en entidades más pequeñas llamadas campos. Los
campos en la tabla CLIENTES consisten en ID, NOMBRE, EDAD,
DIRECCIÓN y SALARIO.
Un campo es una columna en una tabla que está diseñada para mantener
información específica sobre cada registro en la tabla.
Síguenos en Instagram para que estés al tanto de los

nuevos libros de programación. Click aqui
¿Qué es un registro o una fila?
También se llama un registro ya que una fila de datos es cada entrada
individual que existe en una tabla. Por ejemplo, hay 7 registros en la tabla
CLIENTES anterior. A continuación se muestra una sola fila de datos o
registro en la tabla CLIENTES:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
Un registro es una entidad horizontal en una tabla.
¿Qué es una columna?

Una columna es una entidad vertical en una tabla que contiene toda la
información asociada con un campo específico en una tabla.
Por ejemplo, una columna en la tabla CLIENTES es DIRECCIÓN, que
representa la descripción de la ubicación y sería como se muestra a
continuación:
+-----------+
| ADDRESS |
+-----------+
| Ahmedabad |
| Delhi |
| Kota |
| Mumbai |
| Bhopal |
| MP |
| Indore |
+----+------+
¿Qué es un valor NULL?

Un valor NULL en una tabla es un valor en un campo que parece estar en
blanco, lo que significa que un campo con un valor NULL es un campo sin
valor.
Es muy importante comprender que un valor NULL es diferente de un valor
cero o un campo que contiene espacios. Un campo con un valor NULL es el
que se ha dejado en blanco durante la creación de un registro.
Restricciones SQL
Las restricciones son las reglas impuestas en las columnas de datos en una
tabla. Estos se usan para limitar el tipo de datos que pueden ir a una
tabla. Esto garantiza la precisión y fiabilidad de los datos en la base de datos.
Las restricciones pueden ser a nivel de columna o de tabla. Las restricciones
de nivel de columna se aplican solo a una columna, mientras que las
restricciones de nivel de tabla se aplican a toda la tabla.
Las siguientes son algunas de las restricciones más utilizadas disponibles en
SQL:
 Restricción NOT NULL : garantiza que una columna no puede tener un valor
NULL.
 Restricción POR DEFECTO : proporciona un valor predeterminado para una
columna cuando no se especifica ninguno.
 Restricción ÚNICA : garantiza que todos los valores de una columna sean
diferentes.
 Clave PRIMARIA : identifica de forma exclusiva cada fila / registro en una tabla de
base de datos.
 Clave EXTRANJERA : identifica de forma exclusiva una fila / registro en cualquier
otra tabla de base de datos.
 Restricción de COMPROBACIÓN: la restricción de COMPROBACIÓN garantiza
que todos los valores de una columna satisfagan ciertas condiciones.
 ÍNDICE : se utiliza para crear y recuperar datos de la base de datos muy
rápidamente.
Integridad de los datos

Las siguientes categorías de integridad de datos existen con cada RDBMS:
 Integridad de la entidad: no hay filas duplicadas en una tabla.
 Integridad del dominio: aplica entradas válidas para una columna determinada al
restringir el tipo, el formato o el rango de valores.
 Integridad referencial: las filas no se pueden eliminar, que otros registros
utilizan.
 Integridad definida por el usuario: aplica algunas reglas comerciales específicas
que no se incluyen en la entidad, el dominio o la integridad referencial.
Normalización de base de datos

La normalización de la base de datos es el proceso de organizar
eficientemente los datos en una base de datos. Hay dos razones de este
proceso de normalización:
 Eliminar datos redundantes, por ejemplo, almacenar los mismos datos en más de
una tabla.
 Garantizar las dependencias de datos tiene sentido.
Ambas razones son objetivos valiosos, ya que reducen la cantidad de espacio
que consume una base de datos y asegura que los datos se almacenen de
forma lógica. La normalización consiste en una serie de pautas que ayudan a
guiarlo en la creación de una buena estructura de base de datos.
Las pautas de normalización se dividen en formas normales; piense en un
formulario como el formato o la forma en que se presenta una estructura de
base de datos. El objetivo de los formularios normales es organizar la
estructura de la base de datos, de modo que cumpla con las reglas de la
primera forma normal, luego la segunda forma normal y finalmente la tercera
forma normal.
Es su elección llevarlo más lejos e ir a la cuarta forma normal, quinta forma
normal, etc., pero en general, la tercera forma normal es más que suficiente.
 Primera forma normal (1NF)

 Segunda forma normal (2NF)
 Tercera forma normal (3NF)
SQL - Bases de datos RDBMS

Hay muchos RDBMS populares disponibles para trabajar. Este tutorial ofrece
una breve descripción de algunos de los RDBMS más populares. Esto lo
ayudaría a comparar sus características básicas.
MySQL
MySQL es una base de datos SQL de código abierto, desarrollada por una
empresa sueca: MySQL AB. MySQL se pronuncia como "my ess-que-ell", en
contraste con SQL, se pronuncia "secuela".
MySQL es compatible con muchas plataformas diferentes, incluidas Microsoft
Windows, las principales distribuciones de Linux, UNIX y Mac OS X.
MySQL tiene versiones gratuitas y de pago, dependiendo de su uso (no
comercial / comercial) y características. MySQL viene con un servidor de base
de datos SQL muy rápido, multiproceso, multiusuario y robusto.
Historia
 Desarrollo de MySQL por Michael Widenius y David Axmark a partir de 1994.

 Primera versión interna de 23 rd mayo de 1995.
 Windows versión fue puesto en libertad el 8 º enero de 1998 para Windows 95 y
NT.
 Versión 3.23: beta de junio de 2000, versión de producción de enero de 2001.
 Versión 4.0: beta de agosto de 2002, versión de producción de marzo de 2003
(sindicatos).
 Versión 4.1: beta de junio de 2004, versión de producción de octubre de 2004.
 Versión 5.0: beta de marzo de 2005, versión de producción en octubre de 2005.
 Sun Microsystems adquiere MySQL AB en el 26 º febrero de 2008.
 Versión 5.1: versión de producción 27 º noviembre de 2008.
Caracteristicas
 Alto rendimiento.
 Alta disponibilidad.
 Escalabilidad y flexibilidad Ejecute cualquier cosa.
 Soporte transaccional robusto.
 Fortalezas de Web y Data Warehouse.
 Fuerte protección de datos.
 Desarrollo integral de aplicaciones.
 Facilidad de gestión.
 Libertad de código abierto y soporte 24 x 7.
 Costo total de propiedad más bajo.
MS SQL Server
MS SQL Server es un sistema de gestión de bases de datos relacionales
desarrollado por Microsoft Inc. Sus lenguajes de consulta principales son:
 T-SQL
 ANSI SQL
Historia
 1987 - Sybase lanza SQL Server para UNIX.

 1988 - Microsoft, Sybase y Aston-Tate portan SQL Server a OS / 2.
 1989: Microsoft, Sybase y Aston-Tate lanzan SQL Server 1.0 para OS / 2.
 1990: se lanza SQL Server 1.1 con soporte para clientes Windows 3.0.
 Aston - Tate abandona el desarrollo de SQL Server.
 2000: Microsoft lanza SQL Server 2000.
 2001: Microsoft lanza XML para SQL Server Web Release 1 (descarga).
 2002 - Microsoft lanza SQLXML 2.0 (renombrado de XML para SQL Server).
 2002 - Microsoft lanza SQLXML 3.0.
 2005: Microsoft lanza SQL Server 2005 el 7 de noviembre de 2005.
Caracteristicas
 Alto rendimiento
 Alta disponibilidad
 Duplicación de bases de datos
 Instantáneas de bases de datos
 Integración CLR
 Service Broker
 Disparadores DDL
 Funciones de clasificación
 Niveles de aislamiento basados en versiones de fila
 Integración XML
 TRATA DE ATRAPARLO
 Correo de base de datos
ORÁCULO
Es un gran sistema de gestión de bases de datos basado en múltiples
usuarios. Oracle es un sistema de gestión de bases de datos relacionales
desarrollado por 'Oracle Corporation'.
Oracle trabaja para administrar eficientemente sus recursos, una base de
datos de información entre los múltiples clientes que solicitan y envían datos
en la red.
Es una excelente opción de servidor de base de datos para la computación
cliente / servidor. Oracle admite todos los principales sistemas operativos tanto
para clientes como para servidores, incluidos MSDOS, NetWare, UnixWare,
OS / 2 y la mayoría de las versiones de UNIX.
Historia
Oracle comenzó en 1977 y celebró sus 32 años maravillosos en la industria

(de 1977 a 2009).
 1977 - Larry Ellison, Bob Miner y Ed Oates fundaron Software Development
Laboratories para emprender el trabajo de desarrollo.
 1979 - Se lanzó la versión 2.0 de Oracle y se convirtió en la primera base de datos
relacional comercial y la primera base de datos SQL. La compañía cambió su
nombre a Relational Software Inc. (RSI).
 1981 - RSI comenzó a desarrollar herramientas para Oracle.
 1982 - RSI fue renombrado a Oracle Corporation.
 1983: Oracle lanzó la versión 3.0, reescrita en lenguaje C y se ejecutó en múltiples
plataformas.
 1984 - Se lanzó Oracle versión 4.0. Contenía características como control de
concurrencia - consistencia de lectura de múltiples versiones, etc.
 1985 - Se lanzó Oracle versión 4.0. Contenía características como control de
concurrencia - consistencia de lectura de múltiples versiones, etc.
 2007 - Oracle lanzó Oracle11g. La nueva versión se centró en mejores particiones,
migración fácil, etc.
Caracteristicas
 Concurrencia
 Consistencia de lectura
 Mecanismos de bloqueo
 Quiesce Database
 Portabilidad
 Base de datos autogestionada
 SQL * Plus
 ASM
 Programador
 Administrador de recursos
 Almacenamiento de datos
 Vistas materializadas
 Índices de mapa de bits
 Tabla de compresión
 Ejecución Paralela
 SQL analítico
 Procesamiento de datos
 Fraccionamiento
MS Access
Este es uno de los productos de Microsoft más populares. Microsoft Access es
un software de administración de bases de datos de nivel básico. La base de
datos de MS Access no solo es económica sino también una base de datos
poderosa para proyectos a pequeña escala.
MS Access utiliza el motor de base de datos Jet, que utiliza un dialecto
específico del lenguaje SQL (a veces denominado Jet SQL).
MS Access viene con la edición profesional del paquete de MS Office. MS
Access tiene una interfaz gráfica intuitiva fácil de usar.
 1992 - Lanzamiento de la versión 1.0 de Access.
 1993 - Access 1.1 lanzado para mejorar la compatibilidad con la inclusión del
lenguaje de programación Access Basic.
 La transición más significativa fue de Access 97 a Access 2000.
 2007 - Access 2007, se introdujo un nuevo formato de base de datos ACCDB que
admite tipos de datos complejos, como campos de valores múltiples y adjuntos.
Caracteristicas
 Los usuarios pueden crear tablas, consultas, formularios e informes y conectarlos

con macros.
 Opción de importar y exportar los datos a muchos formatos, incluidos Excel,
Outlook, ASCII, dBase, Paradox, FoxPro, SQL Server, Oracle, ODBC, etc.
 También existe el formato Jet Database (MDB o ACCDB en Access 2007), que
puede contener la aplicación y los datos en un solo archivo. Esto hace que sea
muy conveniente distribuir la aplicación completa a otro usuario, que puede
ejecutarla en entornos desconectados.
 Microsoft Access ofrece consultas parametrizadas. Se puede hacer referencia a
estas consultas y tablas de acceso desde otros programas como VB6 y .NET a
través de DAO o ADO.
 Las ediciones de escritorio de Microsoft SQL Server se pueden usar con Access
como alternativa al Motor de base de datos Jet.
 Microsoft Access es una base de datos basada en servidor de archivos. A
diferencia de los sistemas de administración de bases de datos relacionales
cliente-servidor (RDBMS), Microsoft Access no implementa disparadores de
bases de datos, procedimientos almacenados o registros de transacciones.
SQL - Sintaxis
A SQL le sigue un conjunto único de reglas y pautas llamado Sintaxis. Este
tutorial le ofrece un comienzo rápido con SQL al enumerar toda la sintaxis
SQL básica.
Todas las declaraciones SQL comienzan con cualquiera de las palabras clave
como SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE,
SHOW y todas las declaraciones terminan con un punto y coma (;).
El punto más importante a tener en cuenta aquí es que SQL no distingue entre
mayúsculas y minúsculas, lo que significa que SELECT y select tienen el
mismo significado en las declaraciones SQL. Mientras que MySQL hace la
diferencia en los nombres de las tablas. Por lo tanto, si está trabajando con
MySQL, debe proporcionar los nombres de las tablas tal como existen en la
base de datos.
Varios sintaxis en SQL

Todos los ejemplos dados en este tutorial han sido probados con un servidor MySQL.
Sentencia SQL SELECT
SELECT column1, column2....columnN

FROM table_name;
Cláusula DISTINCT de SQL
SELECT DISTINCT column1, column2....columnN

FROM table_name;
Cláusula WHERE WHERE

FROM table_name
WHERE CONDITION;
Cláusula SQL Y / O

FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;
Cláusula SQL IN

FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);
Cláusula SQL ENTRE

FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;
Cláusula LIKE de SQL

FROM table_name
WHERE column_name LIKE { PATTERN };
Cláusula SQL ORDER BY

FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};
Cláusula SQL GROUP BY
SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;
Cláusula SQL COUNT
SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;
Cláusula HAVING de SQL

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);
Sentencia SQL CREATE TABLE
CREATE TABLE table_name(

column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);
Sentencia SQL DROP TABLE
DROP TABLE table_name;
Sentencia SQL CREATE INDEX

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);
Sentencia SQL DROP INDEX

ALTER TABLE table_name
DROP INDEX index_name;
Declaración SQL DESC
DESC table_name;
Sentencia SQL TRUNCATE TABLE

TRUNCATE TABLE table_name;
Sentencia SQL ALTER TABLE
ALTER TABLE table_name {ADD|DROP|MODIFY} column_name

{data_ype};
Sentencia SQL ALTER TABLE (Cambiar nombre)
ALTER TABLE table_name RENAME TO new_table_name;
Sentencia SQL INSERT INTO

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);
Declaración de ACTUALIZACIÓN de SQL

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE CONDITION ];
Sentencia DELETE de SQL

DELETE FROM table_name
WHERE {CONDITION};
Sentencia SQL CREATE DATABASE

CREATE DATABASE database_name;
Sentencia SQL DROP DATABASE
DROP DATABASE database_name;
Declaración de uso de SQL

USE database_name;
Sentencia SQL COMMIT

COMMIT;
Sentencia SQL ROLLBACK
ROLLBACK;
SQL - Tipos de datos
Tipo de datos SQL es un atributo que especifica el tipo de datos de cualquier
objeto. Cada columna, variable y expresión tiene un tipo de datos relacionado
en SQL. Puede usar estos tipos de datos mientras crea sus tablas. Puede
elegir un tipo de datos para una columna de tabla según sus requisitos.
SQL Server ofrece seis categorías de tipos de datos para su uso que se
enumeran a continuación:
Tipos de datos numéricos exactos

TIPO DE DATOS DESDE A
Empezando -9,223,372,036,854,775,808 9.223.372.036.854.775.807
En t -2,147,483,648 2,147,483,647
letra pequeña -32,768 32,767
tinyint 00 255
poco 00 1
decimal -10 ^ 38 +1 10 ^ 38 -1
numérico -10 ^ 38 +1 10 ^ 38 -1
dinero -922,337,203,685,477.5808 +922,337,203,685,477.5807
poco dinero -214,748.3648 +214,748.3647
Tipos de datos numéricos aproximados

flotador -1.79E + 308 1.79E + 308
real -3.40E + 38 3.40E + 38
Tipos de datos de fecha y hora

fecha y hora 1 de enero de 1753 31 de diciembre de 9999
hora pequeña 1 de enero de 1900 6 de junio de 2079
fecha Almacena una fecha como el 30 de junio de 1991
hora Almacena una hora del día como las 12:30 p.m.
Nota : Aquí, la fecha y hora tiene una precisión de 3,33 milisegundos, mientras
que la fecha pequeña tiene una precisión de 1 minuto.
Tipos de datos de cadenas de caracteres

No TIPO DE DATOS Y DESCRIPCIÓN
Señor.
1 carbonizarse
Longitud máxima de 8,000 caracteres. (Longitud fija de caracteres no Unicode)
varchar
2
Máximo de 8,000 caracteres. (Datos no Unicode de longitud variable).
varchar (max)
3 Longitud máxima de 2E + 31 caracteres, datos de longitud variable no Unicode
(solo SQL Server 2005).
texto
44 Datos no Unicode de longitud variable con una longitud máxima de
2,147,483,647 caracteres.
Tipos de datos de cadenas de caracteres Unicode

Señor.
1 nchar
Longitud máxima de 4.000 caracteres. (Longitud fija Unicode)
nvarchar
2
Longitud máxima de 4.000 caracteres. (Longitud variable Unicode)
nvarchar (max)
3 Longitud máxima de 2E + 31 caracteres (solo SQL Server 2005). (Longitud
variable Unicode)
ntext
44
Longitud máxima de 1,073,741,823 caracteres. (Longitud variable Unicode)
Tipos de datos binarios

Señor.
1 binario
Longitud máxima de 8,000 bytes (datos binarios de longitud fija)
varbinary
2
Longitud máxima de 8,000 bytes. (Datos binarios de longitud variable)
varbinary (max)
3 Longitud máxima de 2E + 31 bytes (solo SQL Server 2005). (Datos binarios de
longitud variable)
imagen
44
Longitud máxima de 2,147,483,647 bytes. (Datos binarios de longitud variable)
Varios tipos de datos

Señor.
sql_variant
1
Almacena valores de varios tipos de datos compatibles con SQL Server, excepto
texto, ntext y marca de tiempo.
marca de tiempo
2 Almacena un número único de toda la base de datos que se actualiza cada vez
que se actualiza una fila
identificador único
3
Almacena un identificador único global (GUID)
xml
44 Almacena datos XML. Puede almacenar instancias xml en una columna o una
variable (solo SQL Server 2005).
cursor
55
Referencia a un objeto cursor
mesa
66
Almacena un conjunto de resultados para su posterior procesamiento
SQL - Operadores
¿Qué es un operador en SQL?
Un operador es una palabra reservada o un carácter utilizado principalmente
en la cláusula WHERE de una declaración SQL para realizar operaciones,
como comparaciones y operaciones aritméticas. Estos operadores se utilizan
para especificar condiciones en una declaración SQL y para servir como
conjunciones para múltiples condiciones en una declaración.
 Operadores aritméticos
 Operadores de comparación
 Operadores logicos
 Los operadores solían negar condiciones
Operadores aritméticos SQL

Suponga que 'variable a' contiene 10 y 'variable b' tiene 20, entonces -
Mostrar ejemplos
Operador Descripción Ejemplo
Agrega valores a ambos lados del operador. a+b

+ (Adición)
dará 30
Resta el operando de la derecha del operando de la izquierda. a-b

- (Resta)
dará -10
Multiplica los valores a cada lado del operador. a*b

*
dará
(Multiplicación)
200
Divide el operando de la izquierda por el operando de la b/a

/ (División)
derecha. dará 2
Divide el operando de la izquierda por el operando de la b% a

% (Módulo)
derecha y devuelve el resto. dará 0
Operadores de comparación de SQL
Suponga que 'variable a' contiene 10 y 'variable b' tiene 20, entonces -
Mostrar ejemplos
Operador Descripción Ejemplo
Comprueba si los valores de dos operandos son iguales o no, en caso (a = b)

= afirmativo, la condición se vuelve verdadera. no es
cierto.
Comprueba si los valores de dos operandos son iguales o no, si los (a! = b)
!= valores no son iguales, la condición se vuelve verdadera. es
cierto.
Comprueba si los valores de dos operandos son iguales o no, si los (a <> b)
<> valores no son iguales, la condición se vuelve verdadera. es
cierto.
Comprueba si el valor del operando izquierdo es mayor que el valor (a> b)

> del operando derecho, en caso afirmativo, la condición se vuelve no es
verdadera. cierto.
Comprueba si el valor del operando izquierdo es menor que el valor (a <b)

< del operando derecho, en caso afirmativo, la condición se vuelve es
verdadera. cierto.
Comprueba si el valor del operando izquierdo es mayor o igual que el (a> = b)

>= valor del operando derecho, en caso afirmativo, la condición se vuelve no es
verdadera. cierto.
Comprueba si el valor del operando izquierdo es menor o igual que el (a <= b)

<= valor del operando derecho, en caso afirmativo, la condición se vuelve es
verdadera. cierto.
Comprueba si el valor del operando izquierdo no es menor que el

(a! <b)
!< valor del operando derecho, en caso afirmativo, la condición se vuelve
es falso.
verdadera.
Comprueba si el valor del operando izquierdo no es mayor que el (a!> b)

!> valor del operando derecho, en caso afirmativo, la condición se vuelve es
verdadera. cierto.
Operadores lógicos de SQL
Aquí hay una lista de todos los operadores lógicos disponibles en SQL.
Mostrar ejemplos
No Operador y Descripción
Señor.
TODOS
1
El operador ALL se usa para comparar un valor con todos los valores en otro
conjunto de valores.
Y
2 El operador AND permite la existencia de múltiples condiciones en una cláusula
WHERE de una declaración SQL.
NINGUNA
3 El operador CUALQUIER se utiliza para comparar un valor con cualquier valor
aplicable en la lista según la condición.
ENTRE
44 El operador ENTRE se utiliza para buscar valores que están dentro de un
conjunto de valores, dado el valor mínimo y el valor máximo.
EXISTE
55 El operador EXISTS se utiliza para buscar la presencia de una fila en una tabla
especificada que cumple un determinado criterio.
EN
66 El operador IN se utiliza para comparar un valor con una lista de valores literales
que se han especificado.
ME GUSTA
77 El operador LIKE se usa para comparar un valor con valores similares utilizando
operadores comodín.
NO
8 El operador NOT invierte el significado del operador lógico con el que se

utiliza. Por ejemplo: NO EXISTE, NO ENTRE, NO ESTÁ EN, etc. Este es un
operador negativo.
O
99 El operador OR se usa para combinar múltiples condiciones en una cláusula
ES NULO
10
El operador NULL se usa para comparar un valor con un valor NULL.
ÚNICO
11 El operador ÚNICO busca en cada fila de una tabla específica la unicidad (sin
duplicados).
SQL - Expresiones
Una expresión es una combinación de uno o más valores, operadores y
funciones SQL que evalúan un valor. Estas EXPRESIONES SQL son como
fórmulas y están escritas en lenguaje de consulta. También puede usarlos
para consultar en la base de datos un conjunto específico de datos.
Sintaxis
Considere la sintaxis básica de la instrucción SELECT de la siguiente manera:

SELECT column1, column2, columnN
FROM table_name
WHERE [CONDITION|EXPRESSION];
Existen diferentes tipos de expresiones SQL, que se mencionan a
continuación:
 Booleano
 Numérico
 Fecha
Discutamos ahora cada uno de estos en detalle.
Expresiones booleanas
Las expresiones booleanas de SQL obtienen los datos en función de la
coincidencia de un solo valor. La siguiente es la sintaxis:
FROM table_name
WHERE SINGLE VALUE MATCHING EXPRESSION;
Considere la tabla CLIENTES que tiene los siguientes registros:
SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)
La siguiente tabla es un ejemplo simple que muestra el uso de varias

expresiones booleanas de SQL:
SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
+----+-------+-----+---------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+-------+-----+---------+----------+
1 row in set (0.00 sec)
Expresión numérica
Estas expresiones se utilizan para realizar cualquier operación matemática en
cualquier consulta. La siguiente es la sintaxis:
SELECT numerical_expression as OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;
Aquí, la expresión numérica se usa para una expresión matemática o
cualquier fórmula. El siguiente es un ejemplo simple que muestra el uso de
expresiones numéricas de SQL:
SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
| 21 |
+----------+
Hay varias funciones integradas como avg (), sum (), count (), etc., para
realizar lo que se conoce como los cálculos de datos agregados contra una
tabla o una columna de tabla específica.
SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS;
+---------+
| RECORDS |
+---------+
| 7 |
+---------+
Expresiones de fecha
Las expresiones de fecha devuelven los valores actuales de fecha y hora del
sistema:
SQL> SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
Otra expresión de fecha es como se muestra a continuación:
SQL> SELECT GETDATE();;
+-------------------------+
| GETDATE |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
SQL - CREAR base de datos

La instrucción SQL CREATE DATABASE se usa para crear una nueva base
de datos SQL.
Sintaxis
La sintaxis básica de esta instrucción CREATE DATABASE es la siguiente:
CREATE DATABASE DatabaseName;
Siempre el nombre de la base de datos debe ser único dentro del RDBMS.
Ejemplo
Si desea crear una nueva base de datos <testDB>, la instrucción CREATE
DATABASE sería la siguiente:
SQL> CREATE DATABASE testDB;
Asegúrese de tener el privilegio de administrador antes de crear cualquier
base de datos. Una vez que se crea una base de datos, puede verificarla en la
lista de bases de datos de la siguiente manera:
SQL> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| information_schema |
| AMROOD |
| POSTPARAPROGRAMADORES |
| mysql |
| orig |
| test |
| testDB |
+--------------------+
SQL - DROP o DELETE Database
La instrucción SQL DROP DATABASE se usa para descartar una base de
datos existente en el esquema SQL.
Sintaxis
La sintaxis básica de la instrucción DROP DATABASE es la siguiente:
DROP DATABASE DatabaseName;
Ejemplo
Si desea eliminar una base de datos existente <testDB>, la instrucción DROP
DATABASE sería la que se muestra a continuación:
SQL> DROP DATABASE testDB;
NOTA - Tenga cuidado antes de usar esta operación porque al eliminar una
base de datos existente se produciría la pérdida de información completa
almacenada en la base de datos.
Asegúrese de tener el privilegio de administrador antes de descartar cualquier
base de datos. Una vez que se descarta una base de datos, puede verificarla
en la lista de bases de datos como se muestra a continuación:
+--------------------+
| Database |
+--------------------+
| AMROOD |
| mysql |
| orig |
| test |
+--------------------+
SQL - Base de datos SELECT, instrucción

USE
Cuando tiene varias bases de datos en su Esquema SQL, antes de comenzar
su operación, deberá seleccionar una base de datos donde se realizarán todas
las operaciones.
La instrucción SQL USE se usa para seleccionar cualquier base de datos
existente en el esquema SQL.
Sintaxis
La sintaxis básica de la instrucción USE es la siguiente:
USE DatabaseName;
Ejemplo
Puede consultar las bases de datos disponibles como se muestra a
continuación:
+--------------------+
| Database |
+--------------------+
| AMROOD |
| mysql |
| orig |
| test |
+--------------------+
Ahora, si desea trabajar con la base de datos AMROOD, puede ejecutar el

siguiente comando SQL y comenzar a trabajar con la base de datos
AMROOD.
SQL> USE AMROOD;
SQL - CREAR tabla

Crear una tabla básica implica nombrar la tabla y definir sus columnas y el tipo
de datos de cada columna.
La instrucción SQL CREATE TABLE se usa para crear una nueva tabla.
Sintaxis
La sintaxis básica de la instrucción CREATE TABLE es la siguiente:
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);
CREATE TABLE es la palabra clave que le dice al sistema de base de datos lo
que desea hacer. En este caso, desea crear una nueva tabla. El nombre o
identificador único para la tabla sigue la instrucción CREATE TABLE.
Luego, entre paréntesis, aparece la lista que define cada columna de la tabla y
qué tipo de datos es. La sintaxis se vuelve más clara con el siguiente ejemplo.
Se puede crear una copia de una tabla existente utilizando una combinación
de la instrucción CREATE TABLE y la instrucción SELECT. Puede consultar
los detalles completos en Crear tabla usando otra tabla.
Ejemplo
El siguiente bloque de código es un ejemplo, que crea una tabla CLIENTES
con una ID como clave principal y NOT NULL son las restricciones que
muestran que estos campos no pueden ser NULL al crear registros en esta
tabla:
SQL> CREATE TABLE CUSTOMERS(
ID INT NOT NULL,
NAME VARCHAR (20) NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR (25) ,
SALARY DECIMAL (18, 2),
PRIMARY KEY (ID)
);
Puede verificar si su tabla se ha creado correctamente mirando el mensaje
que muestra el servidor SQL; de lo contrario, puede usar el comando DESC
de la siguiente manera:
SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID | int(11) | NO | PRI | | |
| NAME | varchar(20) | NO | | | |
| AGE | int(11) | NO | | | |
| ADDRESS | char(25) | YES | | NULL | |
| SALARY | decimal(18,2) | YES | | NULL | |
+---------+---------------+------+-----+---------+-------+
Ahora, tiene una tabla CLIENTES disponible en su base de datos que puede
usar para almacenar la información requerida relacionada con los clientes.
SQL - DROP o DELETE Table

La instrucción SQL DROP TABLE se usa para eliminar una definición de tabla
y todos los datos, índices, disparadores, restricciones y especificaciones de
permisos para esa tabla.
NOTA : debe tener mucho cuidado al usar este comando porque una vez que
se elimina una tabla, toda la información disponible en esa tabla también se
perderá para siempre.
Sintaxis
La sintaxis básica de esta instrucción DROP TABLE es la siguiente:
DROP TABLE table_name;
Ejemplo
Primero verifiquemos la tabla CLIENTES y luego la eliminaremos de la base
de datos como se muestra a continuación:
+---------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID | int(11) | NO | PRI | | |
| NAME | varchar(20) | NO | | | |
| AGE | int(11) | NO | | | |
| ADDRESS | char(25) | YES | | NULL | |
| SALARY | decimal(18,2) | YES | | NULL | |
+---------+---------------+------+-----+---------+-------+
Esto significa que la tabla CLIENTES está disponible en la base de datos, por
lo tanto, permítanos eliminarla como se muestra a continuación.
SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)
Ahora, si intenta el comando DESC, obtendrá el siguiente error:

ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist
Aquí, TEST es el nombre de la base de datos que estamos usando para

nuestros ejemplos.
SQL - INSERTAR consulta

La instrucción SQL INSERT INTO se usa para agregar nuevas filas de datos
a una tabla en la base de datos.
Sintaxis
Hay dos sintaxis básicas de la instrucción INSERT INTO que se muestran a

continuación.
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);
Aquí, column1, column2, column3, ... columnN son los nombres de las
columnas de la tabla en la que desea insertar los datos.
Es posible que no necesite especificar el nombre de la (s) columna (s) en la
consulta SQL si está agregando valores para todas las columnas de la
tabla. Pero asegúrese de que el orden de los valores esté en el mismo orden
que las columnas de la tabla.
La sintaxis de SQL INSERT INTO será la siguiente:
INSERT INTO TABLE_NAME VALUES
(value1,value2,value3,...valueN);
Ejemplo
Las siguientes declaraciones crearían seis registros en la tabla CLIENTES.

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );

VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );

VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );

VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );

VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );

VALUES (6, 'Komal', 22, 'MP', 4500.00 );
Puede crear un registro en la tabla CLIENTES utilizando la segunda sintaxis

como se muestra a continuación.
INSERT INTO CUSTOMERS
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );
Todas las declaraciones anteriores producirían los siguientes registros en la
tabla CLIENTES como se muestra a continuación.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Rellenar una tabla usando otra tabla
Puede llenar los datos en una tabla a través de la instrucción select sobre otra
tabla; siempre que la otra tabla tenga un conjunto de campos, que son
necesarios para completar la primera tabla.
Aquí está la sintaxis:
INSERT INTO first_table_name [(column1, column2, ...
columnN)]
SELECT column1, column2, ...columnN
FROM second_table_name
[WHERE condition];
SQL - Consulta SELECT
La instrucción SQL SELECT se usa para obtener los datos de una tabla de
base de datos que devuelve estos datos en forma de una tabla de
resultados. Estas tablas de resultados se denominan conjuntos de resultados.
Sintaxis
La sintaxis básica de la instrucción SELECT es la siguiente:
SELECT column1, column2, columnN FROM table_name;
Aquí, column1, column2 ... son los campos de una tabla cuyos valores desea
obtener. Si desea obtener todos los campos disponibles en el campo, puede
usar la siguiente sintaxis.
SELECT * FROM table_name;
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente código es un ejemplo, que buscaría los campos ID, Nombre y

Salario de los clientes disponibles en la tabla CLIENTES.
SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;
Esto produciría el siguiente resultado:
+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 1 | Ramesh | 2000.00 |
| 2 | Khilan | 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
Si desea obtener todos los campos de la tabla CLIENTES, debe utilizar la
siguiente consulta.
Esto produciría el resultado como se muestra a continuación.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
SQL - Cláusula WHERE
La cláusula WHERE de SQL se usa para especificar una condición al
recuperar los datos de una sola tabla o al unirse con varias tablas. Si se
cumple la condición dada, solo devuelve un valor específico de la tabla. Debe
usar la cláusula WHERE para filtrar los registros y obtener solo los registros
necesarios.
La cláusula WHERE no solo se usa en la instrucción SELECT, sino que
también se usa en la instrucción UPDATE, DELETE, etc., que examinaríamos
en los capítulos siguientes.
Sintaxis
La sintaxis básica de la instrucción SELECT con la cláusula WHERE es la que
se muestra a continuación.
FROM table_name
WHERE [condition]
Puede especificar una condición utilizando los operadores lógicos o de
comparación como>, <, =, LIKE, NOT , etc. Los siguientes ejemplos aclararían
este concepto.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente código es un ejemplo que buscaría los campos ID, Nombre y
Salario de la tabla CLIENTES, donde el salario es mayor que 2000:
SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000;
+----+----------+----------+
+----+----------+----------+
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
La siguiente consulta es un ejemplo, que buscaría los campos ID, Nombre y
Salario de la tabla CLIENTES para un cliente con el nombre Hardik .
Aquí, es importante tener en cuenta que todas las cadenas deben aparecer entre comillas
simples (''). Mientras que, los valores numéricos deben darse sin ninguna cita como en el
ejemplo anterior.
FROM CUSTOMERS
WHERE NAME = 'Hardik';
+----+----------+----------+
+----+----------+----------+
| 5 | Hardik | 8500.00 |
+----+----------+----------+
SQL: operadores conjuntivos AND y OR
Los operadores SQL AND & OR se utilizan para combinar varias condiciones
para limitar los datos en una instrucción SQL. Estos dos operadores se
denominan operadores conjuntivos.
Estos operadores proporcionan un medio para realizar comparaciones
múltiples con diferentes operadores en la misma instrucción SQL.
El operador AND
El operador AND permite la existencia de múltiples condiciones en una
cláusula WHERE de una declaración SQL.
Sintaxis
La sintaxis básica del operador AND con una cláusula WHERE es la siguiente:
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];
Puede combinar N número de condiciones con el operador AND. Para que la
instrucción SQL tome una acción, ya sea una transacción o una consulta,
todas las condiciones separadas por AND deben ser VERDADERAS.
Ejemplo

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es un ejemplo, que buscaría los campos ID, Nombre y Salario de
la tabla CLIENTES, donde el salario es mayor a 2000 y la edad es menor a 25
años.
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;
+----+-------+----------+
+----+-------+----------+
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+-------+----------+
El operador de quirófano
El operador OR se usa para combinar múltiples condiciones en una cláusula
Sintaxis
La sintaxis básica del operador OR con una cláusula WHERE es la siguiente:

FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]
Puede combinar N número de condiciones con el operador OR. Para que la
instrucción SQL tome una acción, ya sea una transacción o una consulta, la
única UNA de las condiciones separadas por el OR debe ser VERDADERO.
Ejemplo

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente bloque de código tiene una consulta, que buscaría los campos ID,
Nombre y Salario de la tabla CLIENTES, donde el salario es superior a 2000 O
la edad es inferior a 25 años.
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;
+----+----------+----------+
+----+----------+----------+
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
SQL - Consulta de ACTUALIZACIÓN
La consulta SQL UPDATE se usa para modificar los registros existentes en
una tabla. Puede usar la cláusula WHERE con la consulta UPDATE para
actualizar las filas seleccionadas, de lo contrario, todas las filas se verían
afectadas.
Sintaxis
La sintaxis básica de la consulta UPDATE con una cláusula WHERE es la
siguiente:
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];
Puede combinar N número de condiciones utilizando los operadores AND u
OR.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
La siguiente consulta actualizará la DIRECCIÓN para un cliente cuyo número
de identificación es 6 en la tabla.
SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;
Ahora, la tabla CLIENTES tendría los siguientes registros:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | Pune | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Si desea modificar todos los valores de la columna DIRECCIÓN y SALARIO
en la tabla CLIENTES, no necesita usar la cláusula WHERE ya que la consulta
ACTUALIZAR sería suficiente como se muestra en el siguiente bloque de
código.
SET ADDRESS = 'Pune', SALARY = 1000.00;
Ahora, la tabla CLIENTES tendría los siguientes registros:

+----+----------+-----+---------+---------+
+----+----------+-----+---------+---------+
| 1 | Ramesh | 32 | Pune | 1000.00 |
| 2 | Khilan | 25 | Pune | 1000.00 |
| 3 | kaushik | 23 | Pune | 1000.00 |
| 4 | Chaitali | 25 | Pune | 1000.00 |
| 5 | Hardik | 27 | Pune | 1000.00 |
| 6 | Komal | 22 | Pune | 1000.00 |
| 7 | Muffy | 24 | Pune | 1000.00 |
+----+----------+-----+---------+---------+
SQL - BORRAR consulta
La consulta DELETE de SQL se usa para eliminar los registros existentes de
una tabla.
Puede usar la cláusula WHERE con una consulta DELETE para eliminar las
filas seleccionadas, de lo contrario, se eliminarían todos los registros.
Sintaxis
La sintaxis básica de la consulta DELETE con la cláusula WHERE es la
siguiente:
DELETE FROM table_name
WHERE [condition];
OR.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente código tiene una consulta, que BORRARÁ un cliente, cuyo ID es
6.
SQL> DELETE FROM CUSTOMERS
WHERE ID = 6;
Ahora, la tabla CLIENTES tendría los siguientes registros.

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Si desea ELIMINAR todos los registros de la tabla CLIENTES, no necesita
usar la cláusula WHERE y la consulta DELETE sería la siguiente:
SQL> DELETE FROM CUSTOMERS;
Ahora, la tabla CLIENTES no tendría ningún registro.
Cláusula SQL - LIKE

La cláusula LIKE de SQL se usa para comparar un valor con valores similares
utilizando operadores comodín. Hay dos comodines utilizados junto con el
operador LIKE.
 El signo de porcentaje (%)

 El guión bajo (_)
El signo de porcentaje representa cero, uno o varios caracteres. El guión bajo
representa un solo número o carácter. Estos símbolos se pueden usar en
combinaciones.
Sintaxis
La sintaxis básica de% y _ es la siguiente:
SELECT FROM table_name
WHERE column LIKE 'XXXX%'
or

WHERE column LIKE '%XXXX%'
or

WHERE column LIKE 'XXXX_'
or

WHERE column LIKE '_XXXX'
or

WHERE column LIKE '_XXXX_'
OR. Aquí, XXXX podría ser cualquier valor numérico o de cadena.
Ejemplo
La siguiente tabla tiene algunos ejemplos que muestran la parte WHERE que
tiene una cláusula LIKE diferente con los operadores '%' y '_' -
No Declaración y descripción
Señor.
1 DONDE SALARIO COMO '200%'

Encuentra cualquier valor que comience con 200.
DONDE SALARIO COMO '% 200%'

2
Encuentra cualquier valor que tenga 200 en cualquier posición.
DONDE SALARIO COMO '_00%'

3
Encuentra cualquier valor que tenga 00 en la segunda y tercera posición.
DONDE SALARIO COMO '2 _% _%'

44 Encuentra cualquier valor que comience con 2 y tenga al menos 3 caracteres de
longitud.
DONDE SALARIO COMO '% 2'

55
Encuentra cualquier valor que termine con 2.
DONDE SALARIO COMO '_2% 3'
66 Encuentra cualquier valor que tenga un 2 en la segunda posición y termine con
un 3.
DONDE SALARIO COMO '2___3'

77 Encuentra cualquier valor en un número de cinco dígitos que comience con 2 y
termine con 3.
Tomemos un ejemplo real, considere la tabla CLIENTES que tiene los

registros como se muestra a continuación.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es un ejemplo, que mostraría todos los registros de la tabla
CLIENTES, donde el SALARIO comienza con 200.
SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+----------+-----+-----------+----------+
SQL - Cláusula TOP, LIMIT o ROWNUM
La cláusula TOP de SQL se usa para obtener un número TOP N o registros de
X porcentaje de una tabla.
Nota : Todas las bases de datos no son compatibles con la cláusula TOP. Por
ejemplo, MySQL admite la cláusula LIMIT para obtener un número limitado de
registros, mientras que Oracle usa el comando ROWNUM para obtener un
número limitado de registros.
Sintaxis
La sintaxis básica de la cláusula TOP con una instrucción SELECT sería la
siguiente.
SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
La siguiente consulta es un ejemplo en el servidor SQL, que buscaría los 3
registros principales de la tabla CLIENTES.
SQL> SELECT TOP 3 * FROM CUSTOMERS;
+----+---------+-----+-----------+---------+
+----+---------+-----+-----------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+
Si está utilizando el servidor MySQL, este es un ejemplo equivalente:
LIMIT 3;

+----+---------+-----+-----------+---------+
+----+---------+-----+-----------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+
Si está utilizando un servidor Oracle, el siguiente bloque de código tiene un
ejemplo equivalente.
WHERE ROWNUM <= 3;

+----+---------+-----+-----------+---------+
+----+---------+-----+-----------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+
SQL - ORDER BY Cláusula
La cláusula ORDER BY de SQL se utiliza para ordenar los datos en orden
ascendente o descendente, en función de una o más columnas. Algunas
bases de datos clasifican los resultados de la consulta en orden ascendente
de forma predeterminada.
Sintaxis
La sintaxis básica de la cláusula ORDER BY es la siguiente:
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];
Puede usar más de una columna en la cláusula ORDER BY. Asegúrese de
que la columna que esté utilizando para ordenar esa columna debe estar en la
lista de columnas.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente bloque de código tiene un ejemplo, que ordenaría el resultado en
orden ascendente por el NOMBRE y el SALARIO:
ORDER BY NAME, SALARY;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
orden descendente por NOMBRE.
ORDER BY NAME DESC;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+-----------+----------+
SQL - Agrupar por
La cláusula SQL GROUP BY se usa en colaboración con la instrucción
SELECT para organizar datos idénticos en grupos. Esta cláusula GROUP BY
sigue la cláusula WHERE en una instrucción SELECT y precede a la cláusula
ORDER BY.
Sintaxis
La sintaxis básica de una cláusula GROUP BY se muestra en el siguiente
bloque de código. La cláusula GROUP BY debe seguir las condiciones de la
cláusula WHERE y debe preceder a la cláusula ORDER BY si se usa una.
SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2
Ejemplo
Considere que la tabla CLIENTES tiene los siguientes registros:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Si desea conocer el monto total del salario de cada cliente, la consulta
GROUP BY sería la siguiente.
SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
GROUP BY NAME;
+----------+-------------+
| NAME | SUM(SALARY) |
+----------+-------------+
| Chaitali | 6500.00 |
| Hardik | 8500.00 |
| kaushik | 2000.00 |
| Khilan | 1500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 2000.00 |
+----------+-------------+
Ahora, veamos una tabla donde la tabla CLIENTES tiene los siguientes
registros con nombres duplicados:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Ramesh | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Ahora, de nuevo, si desea conocer la cantidad total de salario de cada cliente,
la consulta GROUP BY sería la siguiente:
SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
GROUP BY NAME;
+---------+-------------+
| NAME | SUM(SALARY) |
+---------+-------------+
| Hardik | 8500.00 |
| kaushik | 8500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 3500.00 |
+---------+-------------+
SQL: palabra clave distinta
La palabra clave DISTINCT de SQL se usa junto con la instrucción SELECT
para eliminar todos los registros duplicados y obtener solo registros únicos.
Puede haber una situación en la que tenga varios registros duplicados en una
tabla. Al buscar dichos registros, tiene más sentido buscar solo esos registros
únicos en lugar de buscar registros duplicados.
Sintaxis
La sintaxis básica de la palabra clave DISTINCT para eliminar los registros
duplicados es la siguiente:
SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Primero, veamos cómo la siguiente consulta SELECT devuelve los registros
de salario duplicados.
SQL> SELECT SALARY FROM CUSTOMERS
ORDER BY SALARY;
Esto produciría el siguiente resultado, donde el salario (2000) viene dos veces,
que es un registro duplicado de la tabla original.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+
Ahora, usemos la palabra clave DISTINCT con la consulta SELECT anterior y
luego veamos el resultado.
SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
ORDER BY SALARY;
Esto produciría el siguiente resultado donde no tenemos ninguna entrada
duplicada.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+
SQL - Clasificación de resultados
La cláusula ORDER BY de SQL se utiliza para ordenar los datos en orden
ascendente o descendente, en función de una o más columnas. Algunas
bases de datos clasifican los resultados de la consulta en orden ascendente
de forma predeterminada.
Sintaxis
La sintaxis básica de la cláusula ORDER BY que se usaría para ordenar el
resultado en orden ascendente o descendente es la siguiente:
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];
Puede usar más de una columna en la cláusula ORDER BY. Asegúrese de
que cualquier columna que esté utilizando para ordenar, esa columna debe
estar en la lista de columnas.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es un ejemplo, que ordenaría el resultado en orden ascendente

por NOMBRE y SALARIO.
ORDER BY NAME, SALARY;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

orden descendente por NOMBRE.
ORDER BY NAME DESC;

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+-----------+----------+
Para buscar las filas con su propio orden preferido, la consulta SELECT
utilizada sería la siguiente:
ORDER BY (CASE ADDRESS
WHEN 'DELHI' THEN 1
WHEN 'BHOPAL' THEN 2
WHEN 'KOTA' THEN 3
WHEN 'AHMADABAD' THEN 4
WHEN 'MP' THEN 5
ELSE 100 END) ASC, ADDRESS DESC;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Esto ordenará a los clientes por DIRECCIÓN en su propio orden de
preferencia primero y en un orden natural para las direcciones
restantes. Además, las direcciones restantes se ordenarán en orden alfabético
inverso.
SQL - Restricciones
Las restricciones son las reglas impuestas en las columnas de datos de una
tabla. Estos se usan para limitar el tipo de datos que pueden ir a una
tabla. Esto garantiza la precisión y fiabilidad de los datos en la base de datos.
Las restricciones pueden estar en un nivel de columna o en un nivel de
tabla. Las restricciones de nivel de columna se aplican solo a una columna,
mientras que las restricciones de nivel de tabla se aplican a toda la tabla.
Las siguientes son algunas de las restricciones más utilizadas disponibles en
SQL. Estas restricciones ya se han discutido en el capítulo SQL - Conceptos
de RDBMS , pero vale la pena revisarlas en este punto.
 Restricción NOT NULL : garantiza que una columna no puede tener un valor
NULL.
 Restricción POR DEFECTO : proporciona un valor predeterminado para una
columna cuando no se especifica ninguno.
 Restricción ÚNICA : garantiza que todos los valores de una columna sean
diferentes.
 Clave PRIMARIA : identifica de forma exclusiva cada fila / registro en una tabla de
base de datos.
 Clave EXTRANJERA : identifica de forma exclusiva una fila / registro en cualquiera
de la tabla de base de datos dada.
 Restricción de COMPROBACIÓN: la restricción de COMPROBACIÓN garantiza
que todos los valores de una columna satisfagan ciertas condiciones.
 ÍNDICE : se utiliza para crear y recuperar datos de la base de datos muy
rápidamente.
Las restricciones se pueden especificar cuando se crea una tabla con la
instrucción CREATE TABLE o puede usar la instrucción ALTER TABLE para
crear restricciones incluso después de crear la tabla.
Restricciones de caída
Cualquier restricción que haya definido puede eliminarse utilizando el
comando ALTER TABLE con la opción DROP CONSTRAINT.
Por ejemplo, para descartar la restricción de clave principal en la tabla
EMPLEADOS, puede usar el siguiente comando.
ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;
Algunas implementaciones pueden proporcionar accesos directos para
eliminar ciertas restricciones. Por ejemplo, para eliminar la restricción de clave
principal para una tabla en Oracle, puede usar el siguiente comando.
ALTER TABLE EMPLOYEES DROP PRIMARY KEY;
Algunas implementaciones le permiten deshabilitar restricciones. En lugar de

eliminar permanentemente una restricción de la base de datos, puede
deshabilitar temporalmente la restricción y luego habilitarla más tarde.
Restricciones de integridad
Las restricciones de integridad se utilizan para garantizar la precisión y la
coherencia de los datos en una base de datos relacional. La integridad de los
datos se maneja en una base de datos relacional a través del concepto de
integridad referencial.
Hay muchos tipos de restricciones de integridad que juegan un papel en
la integridad referencial (RI) . Estas restricciones incluyen la clave primaria,
la clave externa, las restricciones únicas y otras restricciones que se
mencionan anteriormente.
SQL: uso de combinaciones

La cláusula SQL Joins se usa para combinar registros de dos o más tablas en
una base de datos. Unir es un medio para combinar campos de dos tablas
mediante el uso de valores comunes a cada uno.
Considere las siguientes dos tablas:
Tabla 1 - Tabla de CLIENTES
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Tabla 2 - Tabla de PEDIDOS
+-----+---------------------+-------------+--------+
|OID | DATE | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Ahora, unámonos a estas dos tablas en nuestra instrucción SELECT como se
muestra a continuación.
SQL> SELECT ID, NAME, AGE, AMOUNT
FROM CUSTOMERS, ORDERS
WHERE CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
Esto produciría el siguiente resultado.

+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+
Aquí, se nota que la unión se realiza en la cláusula WHERE. Se pueden usar
varios operadores para unir tablas, como =, <,>, <>, <=,> =,! =, ENTRE, ME
GUSTA y NO; todos se pueden usar para unir tablas. Sin embargo, el
operador más común es el símbolo igual.
Hay diferentes tipos de combinaciones disponibles en SQL:
 UNIÓN INTERNA : devuelve filas cuando hay una coincidencia en ambas tablas.
 LEFT JOIN : devuelve todas las filas de la tabla izquierda, incluso si no hay
coincidencias en la tabla derecha.
 UNIÓN DERECHA : devuelve todas las filas de la tabla derecha, incluso si no hay
coincidencias en la tabla izquierda.
 FULL JOIN : devuelve filas cuando hay una coincidencia en una de las tablas.
 SELF JOIN : se utiliza para unir una tabla consigo misma como si la tabla fuera
dos tablas, renombrando temporalmente al menos una tabla en la instrucción
SQL.
 UNIÓN CARTESIANA : devuelve el producto cartesiano de los conjuntos de
registros de las dos o más tablas unidas.
Discutamos ahora cada una de estas uniones en detalle.
SQL - CLÁUSULA UNIONES

La cláusula / operador SQL UNION se usa para combinar los resultados de
dos o más instrucciones SELECT sin devolver filas duplicadas.
Para usar esta cláusula UNION, cada instrucción SELECT debe tener
 El mismo número de columnas seleccionadas.

 El mismo número de expresiones de columna.
 El mismo tipo de datos y
 Tenerlos en el mismo orden
Pero no necesitan tener que tener la misma longitud.
Sintaxis
La sintaxis básica de una cláusula UNION es la siguiente:
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION

[WHERE condition]
Aquí, la condición dada podría ser cualquier expresión dada según su
requisito.
Ejemplo
Considere las siguientes dos tablas.
Tabla 1 - La tabla CLIENTES es la siguiente.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Tabla 2 - PEDIDOS La tabla es la siguiente.
+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Ahora, unámonos a estas dos tablas en nuestra instrucción SELECT de la
siguiente manera:
SQL> SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION
SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

+------+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+------+----------+--------+---------------------+
| 1 | Ramesh | NULL | NULL |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | NULL | NULL |
| 6 | Komal | NULL | NULL |
| 7 | Muffy | NULL | NULL |
+------+----------+--------+---------------------+
La cláusula UNION ALL

El operador UNION ALL se utiliza para combinar los resultados de dos
instrucciones SELECT, incluidas las filas duplicadas.
Las mismas reglas que se aplican a la cláusula UNION se aplicarán al
operador UNION ALL.
Sintaxis
La sintaxis básica de UNION ALL es la siguiente.

[WHERE condition]
UNION ALL
[WHERE condition]
Aquí, la condición dada podría ser cualquier expresión dada según su
requisito.
Ejemplo
Considere las siguientes dos tablas,

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Tabla 2 - La tabla PEDIDOS es la siguiente.
+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Ahora, unámonos a estas dos tablas en nuestra instrucción SELECT de la

siguiente manera:
SQL> SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
+------+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+------+----------+--------+---------------------+
| 1 | Ramesh | NULL | NULL |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | NULL | NULL |
| 6 | Komal | NULL | NULL |
| 7 | Muffy | NULL | NULL |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+
Hay otras dos cláusulas (es decir, operadores), que son como la cláusula
UNION.
 Cláusula INTERSECT de SQL : se utiliza para combinar dos instrucciones
SELECT, pero solo devuelve filas de la primera instrucción SELECT que son
idénticas a una fila en la segunda instrucción SELECT.
 Cláusula EXCEPT de SQL : combina dos instrucciones SELECT y devuelve filas
de la primera instrucción SELECT que no son devueltas por la segunda
instrucción SELECT.
SQL - Valores NULL

El SQL NULL es el término utilizado para representar un valor faltante. Un
valor NULL en una tabla es un valor en un campo que parece estar en blanco.
Un campo con un valor NULL es un campo sin valor. Es muy importante
comprender que un valor NULL es diferente de un valor cero o un campo que
contiene espacios.
Sintaxis
La sintaxis básica de NULL al crear una tabla.
SQL> CREATE TABLE CUSTOMERS(
ID INT NOT NULL,
NAME VARCHAR (20) NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR (25) ,
SALARY DECIMAL (18, 2),
PRIMARY KEY (ID)
);
Aquí, NOT NULL significa que la columna siempre debe aceptar un valor
explícito del tipo de datos dado. Hay dos columnas donde no utilizamos NOT
NULL, lo que significa que estas columnas podrían ser NULL.
Un campo con un valor NULL es el que se ha dejado en blanco durante la
creación del registro.
Ejemplo
El valor NULL puede causar problemas al seleccionar datos. Sin embargo,
porque al comparar un valor desconocido con cualquier otro valor, el resultado
siempre es desconocido y no se incluye en los resultados. Debe usar
los operadores IS NULL o IS NOT NULL para verificar un valor NULL.
Considere la siguiente tabla CLIENTES con los registros que se muestran a
continuación.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | |
| 7 | Muffy | 24 | Indore | |
+----+----------+-----+-----------+----------+
Ahora, a continuación se muestra el uso del operador IS NOT NULL .
SQL> SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
WHERE SALARY IS NOT NULL;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+-----------+----------+
Ahora, a continuación se muestra el uso del operador IS NULL .
SQL> SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
WHERE SALARY IS NULL;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 6 | Komal | 22 | MP | |
| 7 | Muffy | 24 | Indore | |
+----+----------+-----+-----------+----------+
SQL: sintaxis de alias
Puede cambiar el nombre de una tabla o columna temporalmente dando otro
nombre conocido como Alias . El uso de alias de tabla es cambiar el nombre
de una tabla en una instrucción SQL específica. El cambio de nombre es un
cambio temporal y el nombre real de la tabla no cambia en la base de
datos. Los alias de columna se usan para cambiar el nombre de las columnas
de una tabla con el propósito de una consulta SQL particular.
Sintaxis
La sintaxis básica de un alias de tabla es la siguiente.
SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];
La sintaxis básica de un alias de columna es la siguiente.
SELECT column_name AS alias_name
FROM table_name
WHERE [condition];
Ejemplo
Considere las siguientes dos tablas.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Tabla 2 - PEDIDOS La tabla es la siguiente.
+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Ahora, el siguiente bloque de código muestra el uso de un alias de tabla .
SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT
FROM CUSTOMERS AS C, ORDERS AS O
WHERE C.ID = O.CUSTOMER_ID;

+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+
A continuación se muestra el uso de un alias de columna .
SQL> SELECT ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
FROM CUSTOMERS
WHERE SALARY IS NOT NULL;
+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
| 1 | Ramesh |
| 2 | Khilan |
| 3 | kaushik |
| 4 | Chaitali |
| 5 | Hardik |
| 6 | Komal |
| 7 | Muffy |
+-------------+---------------+
SQL - Índices
Los índices son tablas de búsqueda especiales que el motor de búsqueda
de bases de datos puede usar para acelerar la recuperación de datos. En
pocas palabras, un índice es un puntero a los datos en una tabla. Un índice en
una base de datos es muy similar a un índice en la parte posterior de un libro.
Por ejemplo, si desea hacer referencia a todas las páginas de un libro que
discute un tema determinado, primero debe consultar el índice, que enumera
todos los temas alfabéticamente y luego se refiere a uno o más números de
página específicos.
Un índice ayuda a acelerar las consultas SELECT y las cláusulas WHERE ,
pero ralentiza la entrada de datos, con
las declaraciones UPDATE e INSERT . Los índices se pueden crear o
descartar sin ningún efecto en los datos.
Crear un índice implica la instrucción CREATE INDEX , que le permite
nombrar el índice, especificar la tabla y qué columna o columnas indexar, e
indicar si el índice está en orden ascendente o descendente.
Los índices también pueden ser únicos, como la restricción ÚNICA , ya que el
índice evita entradas duplicadas en la columna o combinación de columnas en
las que hay un índice.
El comando CREATE INDEX

La sintaxis básica de un CREATE INDEX es la siguiente.
CREATE INDEX index_name ON table_name;
Índices de una sola columna
Se crea un índice de columna única basado en una sola columna de tabla. La

sintaxis básica es la siguiente.
CREATE INDEX index_name
ON table_name (column_name);
Índices únicos
Los índices únicos se utilizan no solo para el rendimiento, sino también para la
integridad de los datos. Un índice único no permite insertar ningún valor
duplicado en la tabla. La sintaxis básica es la siguiente.
CREATE UNIQUE INDEX index_name
on table_name (column_name);
Índices compuestos
Un índice compuesto es un índice en dos o más columnas de una tabla. Su

sintaxis básica es la siguiente.
CREATE INDEX index_name
on table_name (column1, column2);
Ya sea para crear un índice de una sola columna o un índice compuesto,
tenga en cuenta las columnas que puede usar con mucha frecuencia en la
cláusula WHERE de una consulta como condiciones de filtro.
Si solo se usa una columna, se debe elegir un índice de una sola columna. Si
hubiera dos o más columnas que se usan con frecuencia en la cláusula
WHERE como filtros, el índice compuesto sería la mejor opción.
Índices implícitos
Los índices implícitos son índices que el servidor de la base de datos crea
automáticamente cuando se crea un objeto. Los índices se crean
automáticamente para restricciones de clave principal y restricciones únicas.
El comando DROP INDEX

Se puede descartar un índice con el comando DROP de SQL . Se debe tener
cuidado al soltar un índice porque el rendimiento puede disminuir o mejorar.
La sintaxis básica es la siguiente:
DROP INDEX index_name;
Puede consultar el capítulo Restricción de ÍNDICE para ver algunos ejemplos
reales sobre Índices.
¿Cuándo deben evitarse los índices?
Aunque los índices están destinados a mejorar el rendimiento de una base de

datos, hay momentos en que deben evitarse.
Las siguientes pautas indican cuándo debe reconsiderarse el uso de un índice.
 Los índices no deben usarse en tablas pequeñas.
 Tablas que tienen frecuentes actualizaciones de lotes grandes o operaciones de
inserción.
 Los índices no deben usarse en columnas que contengan una gran cantidad de
valores NULL.
 Las columnas que se manipulan con frecuencia no deben indexarse.
SQL - Comando ALTER TABLE

El comando SQL ALTER TABLE se usa para agregar, eliminar o modificar
columnas en una tabla existente. También debe usar el comando ALTER
TABLE para agregar y soltar varias restricciones en una tabla existente.
Sintaxis
La sintaxis básica de un comando ALTER TABLE para agregar una nueva
columna en una tabla existente es la siguiente.
ALTER TABLE table_name ADD column_name datatype;
La sintaxis básica de un comando ALTER TABLE para DROP COLUMN en
una tabla existente es la siguiente.
ALTER TABLE table_name DROP COLUMN column_name;
La sintaxis básica de un comando ALTER TABLE para cambiar el TIPO DE
DATOS de una columna en una tabla es la siguiente.
ALTER TABLE table_name MODIFY COLUMN column_name datatype;
La sintaxis básica de un comando ALTER TABLE para agregar
una restricción NOT NULL a una columna en una tabla es la siguiente.
ALTER TABLE table_name MODIFY column_name datatype NOT NULL;
La sintaxis básica de ALTER TABLE para AGREGAR RESTRICCIONES
ÚNICAS a una tabla es la siguiente.
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1,
column2...);
La sintaxis básica de un comando ALTER TABLE para AGREGAR CHECK
CONSTRAINT a una tabla es la siguiente.
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);
La sintaxis básica de un comando ALTER TABLE para AGREGAR
la restricción PRIMARY KEY a una tabla es la siguiente.
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1,
column2...);
La sintaxis básica de un comando ALTER TABLE para DROP
CONSTRAINT de una tabla es la siguiente.
DROP CONSTRAINT MyUniqueConstraint;
Si está utilizando MySQL, el código es el siguiente:
DROP INDEX MyUniqueConstraint;
La sintaxis básica de un comando ALTER TABLE para DROP PRIMARY
KEY de una tabla es la siguiente.
DROP CONSTRAINT MyPrimaryKey;
Si está utilizando MySQL, el código es el siguiente:
DROP PRIMARY KEY;
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es el ejemplo para AGREGAR una nueva columna a una tabla
existente:
ALTER TABLE CUSTOMERS ADD SEX char(1);
Ahora, la tabla CUSTOMERS cambia y se generará el siguiente resultado de
la instrucción SELECT.
+----+---------+-----+-----------+----------+------+
| ID | NAME | AGE | ADDRESS | SALARY | SEX |
+----+---------+-----+-----------+----------+------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 | NULL |
| 2 | Ramesh | 25 | Delhi | 1500.00 | NULL |
| 3 | kaushik | 23 | Kota | 2000.00 | NULL |
| 4 | kaushik | 25 | Mumbai | 6500.00 | NULL |
| 5 | Hardik | 27 | Bhopal | 8500.00 | NULL |
| 6 | Komal | 22 | MP | 4500.00 | NULL |
| 7 | Muffy | 24 | Indore | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+
El siguiente es el ejemplo para DROP columna de sexo de la tabla existente.
ALTER TABLE CUSTOMERS DROP SEX;
Ahora, la tabla CUSTOMERS cambia y la siguiente sería la salida de la
instrucción SELECT.
+----+---------+-----+-----------+----------+
+----+---------+-----+-----------+----------+
| 2 | Ramesh | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+---------+-----+-----------+----------+
SQL: comando TRUNCATE TABLE
El comando SQL TRUNCATE TABLE se usa para eliminar datos completos
de una tabla existente.
También puede usar el comando DROP TABLE para eliminar la tabla
completa, pero eliminaría la estructura completa de la tabla de la base de
datos y necesitaría volver a crear esta tabla una vez más si desea almacenar
algunos datos.
Sintaxis
La sintaxis básica de un comando TRUNCATE TABLE es la siguiente.
TRUNCATE TABLE table_name;
Ejemplo
Considere una tabla CLIENTES que tenga los siguientes registros:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es el ejemplo de un comando Truncar.
SQL > TRUNCATE TABLE CUSTOMERS;
Ahora, la tabla CLIENTES está truncada y el resultado de la instrucción
SELECT será como se muestra en el bloque de código a continuación:
Empty set (0.00 sec)
SQL: uso de vistas
Una vista no es más que una declaración SQL que se almacena en la base de
datos con un nombre asociado. Una vista es en realidad una composición de
una tabla en forma de una consulta SQL predefinida.
Una vista puede contener todas las filas de una tabla o seleccionar filas de
una tabla. Se puede crear una vista a partir de una o varias tablas que
dependen de la consulta SQL escrita para crear una vista.
Las vistas, que son un tipo de tablas virtuales, permiten a los usuarios hacer lo
siguiente:
 Estructura los datos de una manera que los usuarios o clases de usuarios
encuentren natural o intuitiva.
 Restrinja el acceso a los datos de tal manera que un usuario pueda ver y (a veces)
modificar exactamente lo que necesita y nada más.
 Resuma datos de varias tablas que se pueden usar para generar informes.
Crear vistas
Las vistas de la base de datos se crean usando la instrucción CREATE
VIEW . Las vistas se pueden crear desde una sola tabla, varias tablas u otra
vista.
Para crear una vista, un usuario debe tener el privilegio de sistema apropiado
de acuerdo con la implementación específica.
La sintaxis básica de CREATE VIEW es la siguiente:
CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];
Puede incluir varias tablas en su instrucción SELECT de manera similar a
como las usa en una consulta SQL SELECT normal.
Ejemplo

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es un ejemplo para crear una vista desde la tabla CLIENTES. Esta
vista se usaría para tener el nombre y la edad del cliente de la tabla
CLIENTES.
SQL > CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM CUSTOMERS;
Ahora, puede consultar CUSTOMERS_VIEW de manera similar a como
consulta una tabla real. El siguiente es un ejemplo para lo mismo.
SQL > SELECT * FROM CUSTOMERS_VIEW;
+----------+-----+
| name | age |
+----------+-----+
| Ramesh | 32 |
| Khilan | 25 |
| kaushik | 23 |
| Chaitali | 25 |
| Hardik | 27 |
| Komal | 22 |
| Muffy | 24 |
+----------+-----+
La opción WITH CHECK

La opción WITH CHECK es una opción de sentencia CREATE VIEW. El
propósito de WITH CHECK OPTION es asegurar que todas las
ACTUALIZACIONES e INSERTOS satisfagan las condiciones en la definición
de la vista.
Si no satisfacen la (s) condición (es), la ACTUALIZACIÓN o INSERTAR
devuelve un error.
El siguiente bloque de código tiene un ejemplo de creación de la misma vista
CUSTOMERS_VIEW con WITH CHECK OPTION.
CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;
La opción WITH CHECK en este caso debería denegar la entrada de cualquier
valor NULL en la columna AGE de la vista, porque la vista está definida por
datos que no tienen un valor NULL en la columna AGE.
Actualización de una vista
Una vista se puede actualizar bajo ciertas condiciones que se detallan a

continuación:
 La cláusula SELECT no puede contener la palabra clave DISTINCT.
 La cláusula SELECT puede no contener funciones de resumen.
 La cláusula SELECT puede no contener funciones establecidas.
 La cláusula SELECT puede no contener operadores de conjunto.
 La cláusula SELECT no puede contener una cláusula ORDER BY.
 La cláusula FROM no puede contener varias tablas.
 La cláusula WHERE no puede contener subconsultas.
 La consulta no puede contener GROUP BY o HAVING.
 Las columnas calculadas no pueden actualizarse.
 Todas las columnas NOT NULL de la tabla base deben incluirse en la vista para
que la consulta INSERT funcione.
Por lo tanto, si una vista cumple con todas las reglas mencionadas
anteriormente, puede actualizar esa vista. El siguiente bloque de código tiene
un ejemplo para actualizar la edad de Ramesh.
SQL > UPDATE CUSTOMERS_VIEW
SET AGE = 35
WHERE name = 'Ramesh';
En última instancia, esto actualizaría la tabla base CLIENTES y lo mismo se

reflejaría en la vista misma. Ahora, intente consultar la tabla base y la
instrucción SELECT producirá el siguiente resultado.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Insertar filas en una vista
Se pueden insertar filas de datos en una vista. Las mismas reglas que se
aplican al comando ACTUALIZAR también se aplican al comando INSERTAR.
Aquí, no podemos insertar filas en CUSTOMERS_VIEW porque no hemos
incluido todas las columnas NOT NULL en esta vista; de lo contrario, puede
insertar filas en una vista de forma similar a como las inserta en una tabla.
Eliminar filas en una vista
Las filas de datos se pueden eliminar de una vista. Las mismas reglas que se
aplican a los comandos UPDATE e INSERT se aplican al comando DELETE.
El siguiente es un ejemplo para eliminar un registro que tiene EDAD = 22.
SQL > DELETE FROM CUSTOMERS_VIEW
WHERE age = 22;
Esto finalmente eliminaría una fila de la tabla base CLIENTES y lo mismo se
reflejaría en la vista misma. Ahora, intente consultar la tabla base y la
instrucción SELECT producirá el siguiente resultado.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Vistas caídas
Obviamente, donde tiene una vista, necesita una forma de soltar la vista si ya
no es necesaria. La sintaxis es muy simple y se da a continuación:
DROP VIEW view_name;
El siguiente es un ejemplo para descartar CUSTOMERS_VIEW de la tabla
CUSTOMERS.
DROP VIEW CUSTOMERS_VIEW;
SQL - Tener cláusula

La cláusula HAVING le permite especificar condiciones que filtran qué
resultados de grupo aparecen en los resultados.
La cláusula WHERE coloca condiciones en las columnas seleccionadas,
mientras que la cláusula HAVING coloca condiciones en los grupos creados
por la cláusula GROUP BY.
Sintaxis
El siguiente bloque de código muestra la posición de la Cláusula HAVING en
una consulta.
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
La cláusula HAVING debe seguir a la cláusula GROUP BY en una consulta y
también debe preceder a la cláusula ORDER BY si se usa. El siguiente bloque
de código tiene la sintaxis de la instrucción SELECT, incluida la cláusula
HAVING:
SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2
Ejemplo
Considere la tabla CLIENTES que tiene los siguientes registros.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es un ejemplo, que mostraría un registro para un conteo de edad

similar que sería mayor o igual a 2.
SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

+ ---- + -------- + ----- + --------- + --------- +
El | ID | NOMBRE | EDAD | DIRECCION | SALARIO |
+ ---- + -------- + ----- + --------- + --------- +
El | 2 | Khilan | 25 Delhi | 1500,00 |
+ ---- + -------- + ----- + --------- + --------- +
SQL - Transacciones
Una transacción es una unidad de trabajo que se realiza contra una base de
datos. Las transacciones son unidades o secuencias de trabajo realizadas en
un orden lógico, ya sea de forma manual por un usuario o automáticamente
por algún tipo de programa de base de datos.
Una transacción es la propagación de uno o más cambios en la base de
datos. Por ejemplo, si está creando un registro o actualizando un registro o
eliminando un registro de la tabla, entonces está realizando una transacción
en esa tabla. Es importante controlar estas transacciones para garantizar la
integridad de los datos y manejar los errores de la base de datos.
Prácticamente, agrupará muchas consultas SQL en un grupo y las ejecutará
todas juntas como parte de una transacción.
Propiedades de transacciones
Las transacciones tienen las siguientes cuatro propiedades estándar,
generalmente referidas por el acrónimo ACID .
 Atomicidad : garantiza que todas las operaciones dentro de la unidad de trabajo
se completen con éxito. De lo contrario, la transacción se cancela en el punto de
falla y todas las operaciones anteriores se revierten a su estado anterior.
 Consistencia : garantiza que la base de datos cambie correctamente los estados
tras una transacción confirmada con éxito.
 Aislamiento : permite que las transacciones operen independientemente y sean
transparentes entre sí.
 Durabilidad : garantiza que el resultado o efecto de una transacción
comprometida persista en caso de falla del sistema.
Control de transacciones
Los siguientes comandos se utilizan para controlar las transacciones.

 COMPROMISO - para guardar los cambios.
 ROLLBACK : para revertir los cambios.
 SAVEPOINT : crea puntos dentro de los grupos de transacciones en los que
ROLLBACK.
 SET TRANSACTION : coloca un nombre en una transacción.
Comandos de control transaccional

Los comandos de control transaccional solo se usan con los comandos DML ,
como INSERT, UPDATE y DELETE únicamente. No se pueden usar al crear
tablas o soltarlas porque estas operaciones se confirman automáticamente en
la base de datos.
El comando COMMIT
El comando COMMIT es el comando transaccional utilizado para guardar los

cambios invocados por una transacción en la base de datos.
El comando COMMIT es el comando transaccional utilizado para guardar los
cambios invocados por una transacción en la base de datos. El comando
COMMIT guarda todas las transacciones en la base de datos desde el último
comando COMMIT o ROLLBACK.
La sintaxis para el comando COMMIT es la siguiente.
COMMIT;
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es un ejemplo que eliminaría aquellos registros de la tabla que

tienen edad = 25 y luego COMPROMETER los cambios en la base de datos.
WHERE AGE = 25;
SQL> COMMIT;
Por lo tanto, se eliminarían dos filas de la tabla y la instrucción SELECT
produciría el siguiente resultado.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El comando ROLLBACK
El comando ROLLBACK es el comando transaccional utilizado para deshacer

transacciones que aún no se han guardado en la base de datos. Este
comando solo se puede usar para deshacer transacciones desde que se
emitió el último comando COMMIT o ROLLBACK.
La sintaxis para un comando ROLLBACK es la siguiente:
ROLLBACK;
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente es un ejemplo, que eliminaría aquellos registros de la tabla que
tienen la edad = 25 y luego ROLLBACK los cambios en la base de datos.
WHERE AGE = 25;
SQL> ROLLBACK;
Por lo tanto, la operación de eliminación no afectaría la tabla y la instrucción
SELECT produciría el siguiente resultado.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El comando SAVEPOINT
Un SAVEPOINT es un punto en una transacción cuando puede revertir la

transacción a un cierto punto sin revertir toda la transacción.
La sintaxis para un comando SAVEPOINT es la que se muestra a
continuación.
SAVEPOINT SAVEPOINT_NAME;
Este comando solo sirve en la creación de un SAVEPOINT entre todas las
declaraciones transaccionales. El comando ROLLBACK se usa para deshacer
un grupo de transacciones.
La sintaxis para volver a un SAVEPOINT es la que se muestra a continuación.
ROLLBACK TO SAVEPOINT_NAME;
El siguiente es un ejemplo en el que planea eliminar los tres registros
diferentes de la tabla CLIENTES. Desea crear un SAVEPOINT antes de cada
eliminación, de modo que pueda ROLLBACK a cualquier SAVEPOINT en
cualquier momento para devolver los datos apropiados a su estado original.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente bloque de código contiene la serie de operaciones.

SQL> SAVEPOINT SP1;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=1;
1 row deleted.
SQL> SAVEPOINT SP2;
Savepoint created.
1 row deleted.
SQL> SAVEPOINT SP3;
Savepoint created.
1 row deleted.
Ahora que se han producido las tres eliminaciones, supongamos que ha

cambiado de opinión y ha decidido ROLLBACK a SAVEPOINT que identificó
como SP2. Debido a que SP2 se creó después de la primera eliminación, las
dos últimas eliminaciones se deshacen:
SQL> ROLLBACK TO SP2;
Rollback complete.
Observe que solo se realizó la primera eliminación desde que regresó a SP2.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
6 rows selected.
El comando RELEASE SAVEPOINT
El comando RELEASE SAVEPOINT se usa para eliminar un SAVEPOINT que

ha creado.
La sintaxis para un comando RELEASE SAVEPOINT es la siguiente.
RELEASE SAVEPOINT SAVEPOINT_NAME;
Una vez que se ha liberado un SAVEPOINT, ya no puede usar el comando
ROLLBACK para deshacer las transacciones realizadas desde el último
SAVEPOINT.
El comando SET TRANSACTION
El comando SET TRANSACTION se puede usar para iniciar una transacción

de base de datos. Este comando se utiliza para especificar características
para la transacción que sigue. Por ejemplo, puede especificar que una
transacción sea de solo lectura o lectura y escritura.
La sintaxis para un comando SET TRANSACTION es la siguiente.
SET TRANSACTION [ READ WRITE | READ ONLY ];
SQL: operadores comodín
Ya hemos discutido sobre el operador SQL LIKE, que se utiliza para comparar
un valor con valores similares utilizando los operadores comodín.
SQL admite dos operadores comodín junto con el operador LIKE que se
explican en detalle en la siguiente tabla.
No Comodín y descripción
Señor.
El signo de porcentaje (%)

1 Coincide con uno o más personajes.
Nota : MS Access utiliza el carácter comodín de asterisco (*) en lugar del
carácter comodín de signo de porcentaje (%).
El guión bajo (_)

Coincide con un personaje.
2
Nota : MS Access utiliza un signo de interrogación (?) En lugar del guión bajo (_)
para que coincida con cualquier carácter.
El signo de porcentaje representa cero, uno o varios caracteres. El guión bajo

representa un número único o un carácter. Estos símbolos se pueden usar en
combinaciones.
Sintaxis
La sintaxis básica de un operador '%' y '_' es la siguiente.
WHERE column LIKE 'XXXX%'
or

WHERE column LIKE '%XXXX%'
or

WHERE column LIKE 'XXXX_'
or

WHERE column LIKE '_XXXX'
or

WHERE column LIKE '_XXXX_'
OR. Aquí, XXXX podría ser cualquier valor numérico o de cadena.
Ejemplo
La siguiente tabla tiene varios ejemplos que muestran la parte WHERE que
tiene diferentes cláusulas LIKE con operadores '%' y '_'.
No Declaración y descripción
Señor.
1 DONDE SALARIO COMO '200%'

Encuentra cualquier valor que comience con 200.
DONDE SALARIO COMO '% 200%'

2
Encuentra cualquier valor que tenga 200 en cualquier posición.
DONDE SALARIO COMO '_00%'

3
Encuentra cualquier valor que tenga 00 en la segunda y tercera posición.
DONDE SALARIO COMO '2 _% _%'
44 Encuentra cualquier valor que comience con 2 y tenga al menos 3 caracteres de
longitud.
DONDE SALARIO COMO '% 2'

55
Encuentra cualquier valor que termine con 2.
DONDE SALARIO COMO '_2% 3'

66 Encuentra cualquier valor que tenga un 2 en la segunda posición y termine con
un 3.
DONDE SALARIO COMO '2___3'

77 Encuentra cualquier valor en un número de cinco dígitos que comience con 2 y
termine con 3.
Tomemos un ejemplo real, considere la tabla CLIENTES que tiene los

siguientes registros.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
El siguiente bloque de código es un ejemplo, que mostraría todos los registros
de la tabla CLIENTES donde el SALARIO comienza con 200.
WHERE SALARY LIKE '200%';
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+----------+-----+-----------+----------+
SQL - Funciones de fecha
La siguiente tabla tiene una lista de todas las funciones importantes
relacionadas con la fecha y la hora disponibles a través de SQL. Hay varias
otras funciones compatibles con su RDBMS. La lista dada se basa en MySQL
RDBMS.
No Función descriptiva
Señor.
AGREGAR ()
1
Agrega fechas
AGREGAR TIEMPO()
2
Agrega tiempo
CONVERT_TZ ()
3
Convierte de una zona horaria a otra
CURDATE ()
44
Devuelve la fecha actual
CURRENT_DATE (), CURRENT_DATE

55
Sinónimos para CURDATE ()
CURRENT_TIME (), CURRENT_TIME

66
Sinónimos para CURTIME ()
CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP

77
Sinónimos de NOW ()
CURTIME ()
8
Devuelve la hora actual
DATE_ADD ()
99 Agrega dos fechas
FORMATO DE FECHA()
10
Fecha de formatos como se especifica
DATE_SUB ()
11
Resta dos fechas
FECHA()
12
Extrae la parte de fecha de una expresión de fecha o fecha y hora
DATEDIFF ()
13
Resta dos fechas
DÍA()
14 Sinónimo de DAYOFMONTH ()
DAYNAME ()
15
Devuelve el nombre del día de la semana
DIA DEL MES()

dieciséis
Devuelve el día del mes (1-31)
DÍA DE LA SEMANA()
17
Devuelve el índice del día de la semana del argumento
DAYOFYEAR ()
18 años Devuelve el día del año (1-366)
EXTRAER
19
Extrae parte de una fecha
FROM_DAYS ()
20
Convierte un número de día en una fecha
FROM_UNIXTIME ()
21
Fecha de formatos como marca de tiempo UNIX
HORA()
22 Extrae la hora
ÚLTIMO DÍA
23
Devuelve el último día del mes para el argumento.
TIEMPO LOCAL (), TIEMPO LOCAL

24
Sinónimo de NOW ()
LOCALTIMESTAMP, LOCALTIMESTAMP ()
25
Sinónimo de NOW ()
26 MAKEDATE ()
Crea una fecha a partir del año y el día del año.
HACER TIEMPO
27
HACER TIEMPO()
MICROSEGUNDO()
28
Devuelve los microsegundos del argumento
MINUTO()
29
Devuelve el minuto del argumento
MES()
30
Devuelve el mes desde la fecha pasada
NOMBRE DEL MES ()

31
Devuelve el nombre del mes.
AHORA()
32
Devuelve la fecha y hora actuales
PERIOD_ADD ()
33
Agrega un período a un año-mes
PERIOD_DIFF ()
34
Devuelve el número de meses entre períodos.
TRIMESTRE()
35
Devuelve el trimestre de un argumento de fecha
SEC_TO_TIME ()
36
Convierte segundos al formato 'HH: MM: SS'
SEGUNDO()
37 Devuelve el segundo (0-59)
STR_TO_DATE ()
38 Convierte una cadena en una fecha
SUBDATE ()
39
Cuando se invoca con tres argumentos, un sinónimo de DATE_SUB ()
SUBTIME ()
40
Resta tiempos
SYSDATE ()
41 Devuelve la hora a la que se ejecuta la función
FORMATO DE TIEMPO()
42
Formatos como tiempo
TIME_TO_SEC ()
43
Devuelve el argumento convertido a segundos
HORA()
44
Extrae la porción de tiempo de la expresión pasada
TIMEDIFF ()
45 Resta tiempo
TIMESTAMP ()
46 Con un solo argumento, esta función devuelve la expresión de fecha o fecha y
hora. Con dos argumentos, la suma de los argumentos
TIMESTAMPADD ()
47
Agrega un intervalo a una expresión de fecha y hora
TIMESTAMPDIFF ()
48
Resta un intervalo de una expresión de fecha y hora
TO_DAYS ()
49
Devuelve el argumento de fecha convertido a días
UNIX_TIMESTAMP ()
50 Devuelve una marca de tiempo UNIX
UTC_DATE ()
51
Devuelve la fecha UTC actual
UTC_TIME ()
52
Devuelve la hora UTC actual
53 UTC_TIMESTAMP ()
Devuelve la fecha y hora UTC actual
SEMANA()
54
Devuelve el número de semana.
DÍA LABORABLE()
55
Devuelve el índice del día de la semana.
WEEKOFYEAR ()
56
Devuelve la semana calendario de la fecha (1-53)
AÑO()
57
Devuelve el año
AÑO ()
58
Devuelve el año y la semana.
ADDDATE (fecha, unidad expr. INTERVALO),

ADDDATE (expr, días)
Cuando se invoca con la forma INTERVALO del segundo argumento,
ADDDATE () es un sinónimo de DATE_ADD (). La función relacionada
SUBDATE () es un sinónimo de DATE_SUB (). Para obtener información
sobre el argumento de la unidad INTERVALO, consulte la discusión de
DATE_ADD ().
mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1998-02-02 |
+---------------------------------------------------------+
mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);

+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1998-02-02 |
+---------------------------------------------------------+
Cuando se invoca con la forma de días del segundo argumento, MySQL lo
trata como un número entero de días para agregar a expr.
mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1998-02-02 |
+---------------------------------------------------------+
ADDTIME (expr1, expr2)

ADDTIME () agrega expr2 a expr1 y devuelve el resultado. Expr1 es una
expresión de hora o fecha y hora, mientras que expr2 es una expresión de
hora.
mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1
1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001 |
+---------------------------------------------------------+
CONVERT_TZ (dt, from_tz, to_tz)

Esto convierte un valor de fecha y hora dt de la zona horaria dada por from_tz
a la zona horaria dada por to_tz y devuelve el valor resultante. Esta función
devuelve NULL si los argumentos no son válidos.
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET') |
+---------------------------------------------------------+
| 2004-01-01 13:00:00 |
+---------------------------------------------------------+
mysql> SELECT CONVERT_TZ('2004-01-01

12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00') |
+---------------------------------------------------------+
| 2004-01-01 22:00:00 |
+---------------------------------------------------------+
CURDATE ()
Devuelve la fecha actual como un valor en formato 'AAAA-MM-DD' o
AAAAMMDD, dependiendo de si la función se utiliza en una cadena o en un
contexto numérico.
mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE() |
+---------------------------------------------------------+
| 1997-12-15 |
+---------------------------------------------------------+
mysql> SELECT CURDATE() + 0;

+---------------------------------------------------------+
| CURDATE() + 0 |
+---------------------------------------------------------+
| 19971215 |
+---------------------------------------------------------+
CURRENT_DATE y CURRENT_DATE ()
CURRENT_DATE y CURRENT_DATE () son sinónimos de CURDATE ()
CURTIME ()
Devuelve la hora actual como un valor en formato 'HH: MM: SS' o HHMMSS,
dependiendo de si la función se utiliza en una cadena o en un contexto
numérico. El valor se expresa en la zona horaria actual.
mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME() |
+---------------------------------------------------------+
| 23:50:26 |
+---------------------------------------------------------+
mysql> SELECT CURTIME() + 0;

+---------------------------------------------------------+
| CURTIME() + 0 |
+---------------------------------------------------------+
| 235026 |
+---------------------------------------------------------+
CURRENT_TIME y CURRENT_TIME ()
CURRENT_TIME y CURRENT_TIME () son sinónimos de CURTIME ().
CURRENT_TIMESTAMP y CURRENT_TIMESTAMP
()
CURRENT_TIMESTAMP y CURRENT_TIMESTAMP () son sinónimos de
NOW ().
FECHA (expr)
Extrae la parte de fecha de la expresión de fecha o fecha y hora expr.
mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03') |
+---------------------------------------------------------+
| 2003-12-31 |
+---------------------------------------------------------+
DATEDIFF (expr1, expr2)

DATEDIFF () devuelve expr1. expr2 expresado como un valor en días de una
fecha a otra. Tanto expr1 como expr2 son expresiones de fecha o fecha y
hora. Solo las partes de fecha de los valores se utilizan en el cálculo.
mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
DATE_ADD (fecha, unidad expr. INTERVALO),

DATE_SUB (fecha, unidad expr. INTERVALO)
Estas funciones realizan aritmética de fechas. La fecha es un valor
DATETIME o DATE que especifica la fecha de inicio. El expr es una expresión
que especifica el valor del intervalo que se agregará o restará de la fecha de
inicio. El expr es una cadena; puede comenzar con un '-' para intervalos
negativos.
Una unidad es una palabra clave que indica las unidades en las que se debe
interpretar la expresión.
La palabra clave INTERVALO y el especificador de la unidad no distinguen
entre mayúsculas y minúsculas.
La siguiente tabla muestra la forma esperada del argumento expr para cada
valor unitario.
valor unitario ExprFormat esperado

MICROSEGUNDO MICROSECONDS
SEGUNDO SEGUNDOS
MINUTO MINUTOS
HORA Horas
DÍA DIAS
SEMANA SEMANAS
MES MESES
TRIMESTRE CUARTELES
AÑO AÑOS
SEGUNDO_MICROSECOND 'SECONDS.MICROSECONDS'
MINUTE_MICROSECOND 'MINUTOS.MICROSECONDS'
MINUTE_SECOND 'MINUTOS: SEGUNDOS'
HOUR_MICROSECOND 'HORAS. MICROSECONDOS'
HOUR_SECOND 'HORAS: MINUTOS: SEGUNDOS'
HOUR_MINUTE 'HORAS: MINUTOS'
DAY_MICROSECOND 'DAYS.MICROSECONDS'
DÍA_ SEGUNDO 'DÍAS HORAS: MINUTOS: SEGUNDOS'

DAY_MINUTE 'DÍAS HORAS: MINUTOS'
DAY_HOUR 'DÍAS HORAS'
AÑO MES 'AÑOS-MESES'
Los valores QUARTER y WEEK están disponibles en MySQL 5.0.0. versión.

mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
-> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL... |
+---------------------------------------------------------+
| 1998-01-01 00:01:00 |
+---------------------------------------------------------+
mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);

+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR) |
+---------------------------------------------------------+
| 1999-01-01 01:00:00 |
+---------------------------------------------------------+
DATE_FORMAT (fecha, formato)

Este comando formatea el valor de la fecha según la cadena de formato.
Los siguientes especificadores pueden usarse en la cadena de formato. El
carácter '%' se requiere antes de los caracteres del especificador de formato.
No Especificador y Descripción
Señor.
1 %un
Nombre abreviado del día de la semana (Sun..Sat)
%si
2
Nombre abreviado del mes (enero ... diciembre)
%C
3
Mes, numérico (0..12)
%RE
44
Día del mes con sufijo en inglés (0º, 1º, 2º, 3º,.)
%re
55
Día del mes, numérico (00..31)
%mi
66
Día del mes, numérico (0..31)
%F
77
Microsegundos (000000..999999)
%H
8
Hora (00..23)
%h
99
Hora (01..12)
%YO
10
Hora (01..12)
%yo
11
Minutos, numéricos (00..59)
%j
12
Día del año (001..366)
%k
13
Hora (0..23)
%l
14
Hora (1..12)
%METRO
15
Nombre del mes (enero ... diciembre)
%metro
dieciséis
Mes, numérico (00..12)
%pag
17
Am o PM
%r
18 años
Tiempo, 12 horas (hh: mm: ss seguido de AM o PM)
%S
19
Segundos (00..59)
%s
20
Segundos (00..59)
%T
21
Tiempo, 24 horas (hh: mm: ss)
%U
22
Semana (00..53), donde el domingo es el primer día de la semana
%u
23
Semana (00..53), donde el lunes es el primer día de la semana
%V
24 Semana (01..53), donde el domingo es el primer día de la semana; usado con%
X
%v
25
Semana (01..53), donde el lunes es el primer día de la semana; usado con% x
%W
26
Nombre del día de la semana (domingo ... sábado)
27 %w
Día de la semana (0 = domingo..6 = sábado)
%X
28 Año de la semana en que el domingo es el primer día de la semana, numérico,
cuatro dígitos; usado con% V
%X
29 Año de la semana, donde el lunes es el primer día de la semana, numérico,
cuatro dígitos; usado con% v
%Y
30
Año, numérico, cuatro dígitos
%y
31
Año, numérico (dos dígitos)
%%
32
Un literal.%. personaje
%X
33
x, para any.x. no mencionado anteriormente
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');

+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y') |
+---------------------------------------------------------+
| Saturday October 1997 |
+---------------------------------------------------------+
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'

-> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00....... |
+---------------------------------------------------------+
| 22 22 10 10:23:00 PM 22:23:00 00 6 |
+---------------------------------------------------------+
DATE_SUB (fecha, unidad expr. INTERVALO)

Esto es similar a la función DATE_ADD ().
DIA (fecha)
DAY () es sinónimo de la función DAYOFMONTH ().
DAYNAME (fecha)
Devuelve el nombre del día de la semana para la fecha.
mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05') |
+---------------------------------------------------------+
| Thursday |
+---------------------------------------------------------+
DAYOFMONTH (fecha)
Devuelve el día del mes para la fecha, en el rango de 0 a 31.
mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
DAYOFWEEK (fecha)
Devuelve el índice del día de la semana para la fecha (1 = domingo, 2 =
lunes,., 7 = sábado). Estos valores de índice corresponden al estándar ODBC.
mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
DAYOFYEAR (fecha)
Devuelve el día del año para la fecha, en el rango de 1 a 366.
mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03') |
+---------------------------------------------------------+
| 34 |
+---------------------------------------------------------+
EXTRACTO (unidad de fecha)

La función EXTRACT () usa los mismos tipos de especificadores de unidad
que DATE_ADD () o DATE_SUB (), pero extrae partes de la fecha en lugar de
realizar la aritmética de fechas.
mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02') |
+---------------------------------------------------------+
| 1999 |
+---------------------------------------------------------+
mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');

+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03') |
+---------------------------------------------------------+
| 199907 |
+---------------------------------------------------------+
DESDE_DÍAS (N)
Dado un día número N, devuelve un valor DATE.
mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669) |
+---------------------------------------------------------+
| 1997-10-07 |
+---------------------------------------------------------+
Nota : utilice FROM_DAYS () con precaución en fechas anteriores. No está
diseñado para usarse con valores que preceden al advenimiento del
calendario gregoriano (1582).
FROM_UNIXTIME (unix_timestamp)
FROM_UNIXTIME (unix_timestamp, formato)
Devuelve una representación del argumento unix_timestamp como un valor
en formato 'AAAA-MM-DD HH: MM: SS o AAAAMMDDHHMMSS,
dependiendo de si la función se usa en una cadena o en un contexto
numérico. El valor se expresa en la zona horaria actual. El argumento
unix_timestamp es un valor interno de fecha y hora, que es producido por la
función UNIX_TIMESTAMP () .
Si se da el formato, el resultado se formatea de acuerdo con la cadena de
formato, que se usa de la misma manera que se enumera en la entrada para
la función DATE_FORMAT () .
mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580) |
+---------------------------------------------------------+
| 1997-10-04 22:23:00 |
+---------------------------------------------------------+
HORA (tiempo)
Devuelve la hora por tiempo. El rango del valor de retorno es de 0 a 23 para
los valores de hora del día. Sin embargo, el rango de valores TIME es mucho
mayor, por lo que HOUR puede devolver valores mayores que 23.
mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03') |
+---------------------------------------------------------+
| 10 |
+---------------------------------------------------------+
LAST_DAY (fecha)
Toma una fecha o valor de fecha y hora y devuelve el valor correspondiente
para el último día del mes. Devuelve NULL si el argumento no es válido.
mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05') |
+---------------------------------------------------------+
| 2003-02-28 |
+---------------------------------------------------------+
LOCALTIME y LOCALTIME ()
LOCALTIME y LOCALTIME () son sinónimos de NOW ().
LOCALTIMESTAMP y LOCALTIMESTAMP ()
LOCALTIMESTAMP y LOCALTIMESTAMP () son sinónimos de NOW ().
MAKEDATE (año, día del año)
Devuelve una fecha, valores de año y día del año dados. El valor del día del
año debe ser mayor que 0 o el resultado será NULL.
mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32) |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01' |
+---------------------------------------------------------+
MAKETIME (hora, minuto, segundo)

Devuelve un valor de tiempo calculado a partir de los argumentos de hora,
minuto y segundo.
mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30) |
+---------------------------------------------------------+
| '12:15:30' |
+---------------------------------------------------------+
MICROSECOND (expr)
Devuelve los microsegundos de la expresión de hora o fecha y hora (expr)
como un número en el rango de 0 a 999999.
mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456') |
+---------------------------------------------------------+
| 123456 |
+---------------------------------------------------------+
MINUTO (tiempo)
Devuelve el minuto por tiempo, en el rango de 0 a 59.
mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03') |
+---------------------------------------------------------+
| 5 |
+---------------------------------------------------------+
MES (fecha)
Devuelve el mes para la fecha, en el rango de 0 a 12.
mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
NOMBRE DEL MES (fecha)

Devuelve el nombre completo del mes para una fecha.
mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05') |
+---------------------------------------------------------+
| February |
+---------------------------------------------------------+
AHORA()
Devuelve la fecha y hora actuales como un valor en formato 'AAAA-MM-DD
HH: MM: SS' o AAAAMMDDHHMMSS, dependiendo de si la función se utiliza
en una cadena o contexto numérico. Este valor se expresa en la zona horaria
actual.
mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW() |
+---------------------------------------------------------+
| 1997-12-15 23:50:26 |
+---------------------------------------------------------+
PERIOD_ADD (P, N)
Agrega N meses a un período P (en el formato AAAAM o AAAAMM). Devuelve
un valor en el formato AAAAMM. Tenga en cuenta que el argumento de
período P no es un valor de fecha.
mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2) |
+---------------------------------------------------------+
| 199803 |
+---------------------------------------------------------+
PERIOD_DIFF (P1, P2)

Devuelve el número de meses entre los períodos P1 y P2. Estos períodos P1
y P2 deben estar en el formato YYMM o YYYYMM. Tenga en cuenta que los
argumentos de período P1 y P2 no son valores de fecha.
mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703) |
+---------------------------------------------------------+
| 11 |
+---------------------------------------------------------+
TRIMESTRE (fecha)
Devuelve el trimestre del año para la fecha, en el rango de 1 a 4.
mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
Segunda vez)
Devuelve el segundo por tiempo, en el rango de 0 a 59.
mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
SEC_TO_TIME (segundos)
Devuelve el argumento de segundos, convertido a horas, minutos y segundos,
como un valor en formato 'HH: MM: SS' o HHMMSS, dependiendo de si la
función se utiliza en una cadena o contexto numérico.
mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378) |
+---------------------------------------------------------+
| 00:39:38 |
+---------------------------------------------------------+
STR_TO_DATE (str, formato)

Esta es la inversa de la función DATE_FORMAT (). Toma una cadena de
cadena y un formato de cadena de formato. La función STR_TO_DATE ()
devuelve un valor DATETIME si la cadena de formato contiene partes de
fecha y hora. De lo contrario, devuelve un valor de FECHA o HORA si la
cadena contiene solo partes de fecha u hora.
mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y') |
+---------------------------------------------------------+
| 2004-04-31 |
+---------------------------------------------------------+
SUBDATE (fecha, unidad expr. INTERVALO) y

SUBDATE (expr, días)
Cuando se invoca con la forma INTERVALO del segundo argumento,
SUBDATE () es un sinónimo de DATE_SUB (). Para obtener información
sobre el argumento de la unidad INTERVALO, consulte la discusión de
DATE_ADD ().
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1997-12-02 |
+---------------------------------------------------------+
mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);

+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY) |
+---------------------------------------------------------+
| 1997-12-02 |
+---------------------------------------------------------+
SUBTIME (expr1, expr2)

La función SUBTIME () devuelve expr1. expr2 expresado como un valor en el
mismo formato que expr1. El valor expr1 es una expresión de hora o fecha y
hora, mientras que el valor expr2 es una expresión de hora.
mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
-> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'... |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997 |
+---------------------------------------------------------+
SYSDATE ()
Devuelve la fecha y hora actuales como un valor en formato 'AAAA-MM-DD
HH: MM: SS' o AAAAMMDDHHMMSS, dependiendo de si la función se utiliza
en una cadena o en un contexto numérico.
mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE() |
+---------------------------------------------------------+
| 2006-04-12 13:47:44 |
+---------------------------------------------------------+
TIEMPO (expr)
Extrae la parte de tiempo de la expresión de hora o fecha y hora expr y la
devuelve como una cadena.
mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03') |
+---------------------------------------------------------+
| 01:02:03 |
+---------------------------------------------------------+
TIMEDIFF (expr1, expr2)

La función TIMEDIFF () devuelve expr1. expr2 expresado como un valor de
tiempo. Estos valores expr1 y expr2 son expresiones de hora o fecha y hora,
pero ambos deben ser del mismo tipo.
mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
-> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'..... |
+---------------------------------------------------------+
| 46:58:57.999999 |
+---------------------------------------------------------+
TIMESTAMP (expr), TIMESTAMP (expr1, expr2)
Con un único argumento, esta función devuelve la expresión date o datetime
expr como un valor datetime. Con dos argumentos, agrega la expresión de
tiempo expr2 a la expresión de fecha o fecha y hora expr1 y devuelve el
resultado como un valor de fecha y hora.
mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31') |
+---------------------------------------------------------+
| 2003-12-31 00:00:00 |
+---------------------------------------------------------+
TIMESTAMPADD (unidad, intervalo, datetime_expr)

Esta función agrega el intervalo de expresión entero a la expresión date o
datetime datetime_expr . La unidad para el intervalo viene dada por el
argumento de la unidad, que debería ser uno de los siguientes valores:
 FRAC_SECOND
 SEGUNDO MINUTO
 HORA, DIA
 SEMANA
 MES
 TRIMESTRE o
 AÑO
El valor unitario se puede especificar utilizando una de las palabras clave
como se muestra o con un prefijo de SQL_TSI_.
Por ejemplo, DAY y SQL_TSI_DAY son legales.
mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02') |
+---------------------------------------------------------+
| 2003-01-02 00:01:00 |
+---------------------------------------------------------+
TIMESTAMPDIFF (unidad, datetime_expr1,

datetime_expr2)
Devuelve la diferencia de enteros entre las expresiones date o datetime
datetime_expr1 y datetime_expr2. La unidad para el resultado viene dada por
el argumento de la unidad. Los valores legales para la unidad son los mismos
que se enumeran en la descripción de la función TIMESTAMPADD ().
mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
TIME_FORMAT (hora, formato)

Esta función se usa como la función DATE_FORMAT (), pero la cadena de
formato puede contener especificadores de formato solo por horas, minutos y
segundos.
Si el valor del tiempo contiene una parte de la hora que es mayor que 23,
los especificadores de formato % H y% k producen un valor mayor que el
rango habitual de 0 a 23. Los otros especificadores de formato de hora
producen el módulo de valor de hora 12.
mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l') |
+---------------------------------------------------------+
| 100 100 04 04 4 |
+---------------------------------------------------------+
TIME_TO_SEC (hora)
Devuelve el argumento de tiempo convertido a segundos.
mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00') |
+---------------------------------------------------------+
| 80580 |
+---------------------------------------------------------+
Fecha)
Dada una fecha, devuelve un número de día (el número de días desde el año
0).
mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501) |
+---------------------------------------------------------+
| 728779 |
+---------------------------------------------------------+
UNIX_TIMESTAMP (), UNIX_TIMESTAMP (fecha)
Si se llama sin argumento, esta función devuelve una marca de tiempo Unix
(segundos desde '1970-01-01 00:00:00' UTC) como un entero sin signo. Si se
llama a UNIX_TIMESTAMP () con un argumento de fecha, devuelve el valor
del argumento como segundos desde '1970-01-01 00:00:00' UTC. La fecha
puede ser una cadena DATE, una cadena DATETIME, un TIMESTAMP o un
número en el formato YYMMDD o AAAAMMDD.
mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP() |
+---------------------------------------------------------+
| 882226357 |
+---------------------------------------------------------+
mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');

+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00') |
+---------------------------------------------------------+
| 875996580 |
+---------------------------------------------------------+
UTC_DATE, UTC_DATE ()
Devuelve la fecha UTC actual como un valor en formato 'AAAA-MM-DD' o
AAAAMMDD, dependiendo de si la función se utiliza en una cadena o contexto
numérico.
mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0 |
+---------------------------------------------------------+
| 2003-08-14, 20030814 |
+---------------------------------------------------------+
UTC_TIME, UTC_TIME ()
Devuelve el tiempo UTC actual como un valor en formato 'HH: MM: SS' o
HHMMSS, dependiendo de si la función se utiliza en una cadena o contexto
numérico.
mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0 |
+---------------------------------------------------------+
| 18:07:53, 180753 |
+---------------------------------------------------------+
UTC_TIMESTAMP, UTC_TIMESTAMP ()
Devuelve la fecha y hora UTC actual como un valor en 'AAAA-MM-DD HH:
MM: SS' o en un formato AAAAMMDDHHMMSS, dependiendo de si la función
se utiliza en una cadena o en un contexto numérico.
mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0 |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804 |
+---------------------------------------------------------+
SEMANA (fecha [, modo])

Esta función devuelve el número de semana para la fecha. La forma de dos
argumentos de WEEK () le permite especificar si la semana comienza un
domingo o un lunes y si el valor de retorno debe estar en el rango de 0 a 53 o
de 1 a 53. Si se omite el argumento de modo, se utiliza el valor de la variable
de sistema default_week_format
Modo Primer dia de la semana Rango La semana 1 es la primera semana.
00 domingo 0-53 con un domingo de este año
1 lunes 0-53 con más de 3 días este año
2 domingo 1-53 con un domingo de este año
3 lunes 1-53 con más de 3 días este año
44 domingo 0-53 con más de 3 días este año
55 lunes 0-53 con un lunes en este año
66 domingo 1-53 con más de 3 días este año
77 lunes 1-53 con un lunes en este año

mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20') |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
DÍA DE LA SEMANA (fecha)

Devuelve el índice del día de la semana para la fecha (0 = lunes, 1 = martes,
.6 = domingo).
mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
WEEKOFYEAR (fecha)
Devuelve la semana calendario de la fecha como un número en el rango de 1
a 53. WEEKOFYEAR () es una función de compatibilidad que es equivalente a
WEEK (fecha, 3).
mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20') |
+---------------------------------------------------------+
| 8 |
+---------------------------------------------------------+
AÑO (fecha)
Devuelve el año para la fecha, en el rango de 1000 a 9999, o 0 para el
cero. fecha.
mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03') |
+---------------------------------------------------------+
| 1998 |
+---------------------------------------------------------+
SEMANA (fecha), SEMANA (fecha, modo)

Devuelve el año y la semana para una fecha. El argumento de modo funciona
exactamente como el argumento de modo para la función WEEK (). El año en
el resultado puede ser diferente del año en el argumento de fecha para la
primera y la última semana del año.
mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01') |
+---------------------------------------------------------+
| 198653 |
+---------------------------------------------------------+
Nota : El número de semana es diferente de lo que la función WEEK ()
devolvería (0) para los argumentos opcionales 0 o 1, ya que WEEK () luego
devuelve la semana en el contexto del año dado.
SQL - Tablas temporales

¿Qué son las tablas temporales?
Hay RDBMS, que admiten tablas temporales. Las tablas temporales son una
gran característica que le permite almacenar y procesar resultados
intermedios utilizando las mismas capacidades de selección, actualización y
unión que puede usar con las tablas típicas de SQL Server.
Las tablas temporales podrían ser muy útiles en algunos casos para mantener
datos temporales. Lo más importante que se debe conocer para las tablas
temporales es que se eliminarán cuando finalice la sesión actual del cliente.
Las tablas temporales están disponibles en MySQL versión 3.23 en
adelante. Si usa una versión anterior de MySQL que 3.23, no puede usar
tablas temporales, pero puede usar tablas de montón .
Como se indicó anteriormente, las tablas temporales solo durarán mientras la
sesión esté activa. Si ejecuta el código en un script PHP, la tabla temporal se
destruirá automáticamente cuando el script termine de ejecutarse. Si está
conectado al servidor de base de datos MySQL a través del programa cliente
MySQL, la tabla temporal existirá hasta que cierre el cliente o destruya
manualmente la tabla.
Ejemplo
Aquí hay un ejemplo que muestra el uso de una tabla temporal.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
-> product_name VARCHAR(50) NOT NULL
-> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
-> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
-> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
mysql> INSERT INTO SALESSUMMARY
-> (product_name, total_sales, avg_unit_price,
total_units_sold)
-> VALUES
-> ('cucumber', 100.25, 90, 2);
mysql> SELECT * FROM SALESSUMMARY;

+--------------+-------------+----------------+--------------
----+
| product_name | total_sales | avg_unit_price |
total_units_sold |
+--------------+-------------+----------------+--------------
----+
| cucumber | 100.25 | 90.00 |
2 |
+--------------+-------------+----------------+--------------
----+
Cuando emite un comando SHOW TABLES, su tabla temporal no aparecerá

en la lista. Ahora, si cierra la sesión de MySQL y luego emite un comando
SELECCIONAR, no encontrará datos disponibles en la base de datos. Incluso
su tabla temporal no existirá.
Dejar tablas temporales

De forma predeterminada, MySQL elimina todas las tablas temporales cuando
finaliza la conexión de su base de datos. Aún así, si desea eliminarlos en el
medio, puede hacerlo emitiendo un comando DROP TABLE .
El siguiente es un ejemplo sobre cómo soltar una tabla temporal.
mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
-> product_name VARCHAR(50) NOT NULL
-> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
-> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
-> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
mysql> INSERT INTO SALESSUMMARY

-> (product_name, total_sales, avg_unit_price,
total_units_sold)
-> VALUES
-> ('cucumber', 100.25, 90, 2);

+--------------+-------------+----------------+--------------
----+
| product_name | total_sales | avg_unit_price |
total_units_sold |
+--------------+-------------+----------------+--------------
----+
| cucumber | 100.25 | 90.00 |
2 |
+--------------+-------------+----------------+--------------
----+
mysql> DROP TABLE SALESSUMMARY;
ERROR 1146: Table 'TUTORIALS.SALESSUMMARY' doesn't exist
SQL - Tablas de clonación

Puede haber una situación en la que necesite una copia exacta de una tabla y
los comandos CREATE TABLE ... o SELECT ... no se adapten a sus
propósitos porque la copia debe incluir los mismos índices, valores
predeterminados, etc.
Si está utilizando MySQL RDBMS, puede manejar esta situación siguiendo los
pasos que se detallan a continuación:
 Use el comando SHOW CREATE TABLE para obtener una instrucción CREATE
TABLE que especifique la estructura de la tabla de origen, los índices y todo.
 Modifique la instrucción para cambiar el nombre de la tabla al de la tabla de
clonación y ejecute la instrucción. De esta manera tendrá una tabla de clonación
exacta.
 Opcionalmente, si necesita copiar también el contenido de la tabla, emita un
INSERT INTO o una instrucción SELECT también.
Ejemplo
Pruebe el siguiente ejemplo para crear una tabla de clonación
para TUTORIALS_TBL cuya estructura es la siguiente:
Paso 1 : obtenga la estructura completa de la tabla.
SQL> SHOW CREATE TABLE TUTORIALS_TBL \G;
*************************** 1. row
***************************
Table: TUTORIALS_TBL
Create Table: CREATE TABLE 'TUTORIALS_TBL' (
'tutorial_id' int(11) NOT NULL auto_increment,
'tutorial_title' varchar(100) NOT NULL default '',
'tutorial_author' varchar(40) NOT NULL default '',
'submission_date' date default NULL,
PRIMARY KEY ('tutorial_id'),
UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author')
) TYPE = MyISAM
Paso 2 : cambie el nombre de esta tabla y cree otra tabla.
SQL> CREATE TABLE `CLONE_TBL` (
-> 'tutorial_id' int(11) NOT NULL auto_increment,
-> 'tutorial_title' varchar(100) NOT NULL default '',
-> 'tutorial_author' varchar(40) NOT NULL default '',
-> 'submission_date' date default NULL,
-> PRIMARY KEY (`tutorial_id'),
-> UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author')
-> ) TYPE = MyISAM;
Paso 3 : después de ejecutar el paso 2, clonarás una tabla en tu base de
datos. Si desea copiar datos de una tabla anterior, puede hacerlo utilizando la
instrucción INSERT INTO ... SELECT.
SQL> INSERT INTO CLONE_TBL (tutorial_id,
-> tutorial_title,
-> tutorial_author,
-> submission_date)
-> SELECT tutorial_id,tutorial_title,
-> tutorial_author,submission_date,
-> FROM TUTORIALS_TBL;
Records: 3 Duplicates: 0 Warnings: 0
Finalmente, tendrá una tabla de clonación exacta como quería tener.
SQL - Subconsultas
Una consulta de consulta secundaria o interna o una consulta anidada es una
consulta dentro de otra consulta SQL e incrustada dentro de la cláusula
WHERE.
Se utiliza una subconsulta para devolver datos que se utilizarán en la consulta
principal como condición para restringir aún más los datos que se recuperarán.
Las subconsultas se pueden usar con las instrucciones SELECT, INSERT,
UPDATE y DELETE junto con los operadores como =, <,>,> =, <=, IN,
BETWEEN, etc.
Hay algunas reglas que las subconsultas deben seguir:
 Las subconsultas deben estar entre paréntesis.
 Una subconsulta solo puede tener una columna en la cláusula SELECT, a menos
que haya varias columnas en la consulta principal para que la subconsulta
compare sus columnas seleccionadas.
 Un comando ORDER BY no se puede usar en una subconsulta, aunque la
consulta principal puede usar un ORDER BY. El comando GROUP BY se puede
utilizar para realizar la misma función que ORDER BY en una subconsulta.
 Las subconsultas que devuelven más de una fila solo se pueden usar con
operadores de valores múltiples, como el operador IN.
 La lista SELECT no puede incluir referencias a valores que evalúen a BLOB,
ARRAY, CLOB o NCLOB.
 Una subconsulta no puede encerrarse inmediatamente en una función establecida.
 El operador ENTRE no se puede utilizar con una subconsulta. Sin embargo, el
operador ENTRE se puede utilizar dentro de la subconsulta.
Subconsultas con la instrucción SELECT
Las subconsultas se usan con mayor frecuencia con la instrucción
SELECT. La sintaxis básica es la siguiente:
SELECT column_name [, column_name ]
WHERE column_name OPERATOR
(SELECT column_name [, column_name ]
[WHERE])
Ejemplo

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Ahora, verifiquemos la siguiente subconsulta con una instrucción SELECT.

SQL> SELECT *
FROM CUSTOMERS
WHERE ID IN (SELECT ID
FROM CUSTOMERS
WHERE SALARY > 4500) ;

+----+----------+-----+---------+----------+
+----+----------+-----+---------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
Subconsultas con la declaración INSERT

Las subconsultas también se pueden usar con instrucciones INSERT. La
instrucción INSERT usa los datos devueltos por la subconsulta para insertarlos
en otra tabla. Los datos seleccionados en la subconsulta pueden modificarse
con cualquiera de las funciones de carácter, fecha o número.
La sintaxis básica es la siguiente.
INSERT INTO table_name [ (column1 [, column2 ]) ]
SELECT [ *|column1 [, column2 ]
[ WHERE VALUE OPERATOR ]
Ejemplo
Considere una tabla CUSTOMERS_BKP con una estructura similar a la tabla

CUSTOMERS. Ahora, para copiar la tabla CUSTOMERS completa en la tabla
CUSTOMERS_BKP, puede usar la siguiente sintaxis.
SQL> INSERT INTO CUSTOMERS_BKP
SELECT * FROM CUSTOMERS
WHERE ID IN (SELECT ID
FROM CUSTOMERS) ;
Subconsultas con la Declaración ACTUALIZADA

La subconsulta se puede usar junto con la instrucción UPDATE. Se pueden
actualizar columnas simples o múltiples en una tabla cuando se utiliza una
subconsulta con la instrucción UPDATE.
UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]
Ejemplo
Suponiendo que tenemos disponible la tabla CUSTOMERS_BKP, que es una

copia de seguridad de la tabla CUSTOMERS. El siguiente ejemplo actualiza
SALARIO en 0.25 veces en la tabla CLIENTES para todos los clientes cuya
EDAD es mayor o igual a 27.
SET SALARY = SALARY * 0.25
WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
WHERE AGE >= 27 );
Esto afectaría dos filas y finalmente la tabla CLIENTES tendría los siguientes
registros.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 2125.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Subconsultas con la declaración DELETE

La subconsulta se puede usar junto con la instrucción DELETE como con
cualquier otra instrucción mencionada anteriormente.
DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]
Ejemplo
Asumiendo, tenemos una tabla CUSTOMERS_BKP disponible que es una

copia de seguridad de la tabla CUSTOMERS. El siguiente ejemplo elimina los
registros de la tabla CLIENTES para todos los clientes cuya EDAD es mayor o
igual a 27.
WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
WHERE AGE >= 27 );
Esto afectaría dos filas y, finalmente, la tabla CLIENTES tendría los siguientes
registros.
+----+----------+-----+---------+----------+
+----+----------+-----+---------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
SQL: uso de secuencias
Una secuencia es un conjunto de enteros 1, 2, 3, ... que se generan en orden
a pedido. Las secuencias se usan con frecuencia en las bases de datos
porque muchas aplicaciones requieren que cada fila de una tabla contenga un
valor único y las secuencias proporcionan una manera fácil de generarlas.
Este capítulo describe cómo usar secuencias en MySQL.
Usando la columna AUTO_INCREMENT

La forma más sencilla en MySQL de utilizar secuencias es definir una columna
como AUTO_INCREMENT y dejar que el resto se encargue de MySQL.
Ejemplo
Pruebe el siguiente ejemplo. Esto creará una tabla y luego insertará algunas
filas en esta tabla donde no es necesario dar una ID de registro porque
MySQL la incrementa automáticamente.
mysql> CREATE TABLE INSECT
-> (
-> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (id),
-> name VARCHAR(30) NOT NULL, # type of insect
-> date DATE NOT NULL, # date collected
-> origin VARCHAR(30) NOT NULL # where collected
);
mysql> INSERT INTO INSECT (id,name,date,origin) VALUES
-> (NULL,'housefly','2001-09-10','kitchen'),
-> (NULL,'millipede','2001-09-10','driveway'),
-> (NULL,'grasshopper','2001-09-10','front yard');
Records: 3 Duplicates: 0 Warnings: 0
mysql> SELECT * FROM INSECT ORDER BY id;
+----+-------------+------------+------------+
| id | name | date | origin |
+----+-------------+------------+------------+
| 1 | housefly | 2001-09-10 | kitchen |
| 2 | millipede | 2001-09-10 | driveway |
| 3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
Obtenga valores de AUTO_INCREMENT

LAST_INSERT_ID () es una función SQL, por lo que puede usarla desde
cualquier cliente que entienda cómo emitir sentencias SQL. De lo contrario, las
secuencias de comandos PERL y PHP proporcionan funciones exclusivas
para recuperar el valor de incremento automático del último registro.
Ejemplo PERL
Use el atributo mysql_insertid para obtener el valor AUTO_INCREMENT

generado por una consulta. Se accede a este atributo a través de un
identificador de base de datos o un identificador de declaración, según cómo
emita la consulta. El siguiente ejemplo lo hace referencia a través del
identificador de la base de datos.
$dbh->do ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')");
my $seq = $dbh->{mysql_insertid};
Ejemplo de PHP
Después de emitir una consulta que genera un valor AUTO_INCREMENT,

recupere el valor llamando a la función mysql_insert_id () .
mysql_query ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);
Renumerar una secuencia existente

Puede haber un caso en el que haya eliminado muchos registros de una tabla
y desee volver a secuenciar todos los registros. Esto se puede hacer usando
un simple truco, pero debe tener mucho cuidado de hacer esto y verificar si su
mesa se está uniendo con otra mesa o no.
Si determina que volver a secuenciar una columna AUTO_INCREMENT es
inevitable, la forma de hacerlo es quitar la columna de la tabla y luego
agregarla nuevamente.
El siguiente ejemplo muestra cómo renumerar los valores de identificación en
la tabla de insectos utilizando esta técnica.
mysql> ALTER TABLE INSECT DROP id;
mysql> ALTER TABLE insect
-> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
-> ADD PRIMARY KEY (id);
Comenzar una secuencia en un valor particular

Por defecto, MySQL iniciará la secuencia desde 1, pero también puede
especificar cualquier otro número en el momento de la creación de la tabla.
El siguiente bloque de código tiene un ejemplo donde MySQL iniciará la
secuencia desde 100.
mysql> CREATE TABLE INSECT
-> (
-> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
-> PRIMARY KEY (id),
-> name VARCHAR(30) NOT NULL, # type of insect
-> date DATE NOT NULL, # date collected
-> origin VARCHAR(30) NOT NULL # where collected
);
Alternativamente, puede crear la tabla y luego establecer el valor de secuencia
inicial con ALTER TABLE.
mysql> ALTER TABLE t AUTO_INCREMENT = 100;
SQL - Manejo de duplicados
Puede haber una situación en la que tenga varios registros duplicados en una
tabla. Al buscar dichos registros, tiene más sentido buscar solo registros
únicos en lugar de buscar registros duplicados.
La palabra clave SQL DISTINCT , que ya hemos discutido, se usa junto con la
instrucción SELECT para eliminar todos los registros duplicados y obtener solo
los registros únicos.
Sintaxis
La sintaxis básica de una palabra clave DISTINCT para eliminar registros
duplicados es la siguiente.
SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Primero, veamos cómo la siguiente consulta SELECT devuelve registros de
salario duplicados.
SQL> SELECT SALARY FROM CUSTOMERS
ORDER BY SALARY;
Esto produciría el siguiente resultado donde el salario de 2000 se duplicará, lo
cual es un registro duplicado de la tabla original.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+
Ahora, usemos la palabra clave DISTINCT con la consulta SELECT anterior y
veamos el resultado.
SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
ORDER BY SALARY;
Esto produciría el siguiente resultado donde no tenemos ninguna entrada

duplicada.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+
Inyección SQL
Si toma una entrada del usuario a través de una página web y la inserta en
una base de datos SQL, existe la posibilidad de que se haya dejado abierto
para un problema de seguridad conocido como la inyección SQL . Este
capítulo le enseñará cómo ayudar a evitar que esto suceda y lo ayudará a
proteger sus scripts y declaraciones SQL en los scripts del lado del servidor,
como un script PERL.
La inyección generalmente ocurre cuando le pide al usuario una entrada,
como su nombre y, en lugar de un nombre, le dan una declaración SQL que
ejecutará sin saberlo en su base de datos. Nunca confíe en los datos
proporcionados por el usuario, procese estos datos solo después de la
validación; como regla general, esto se hace mediante Pattern Matching .
En el ejemplo a continuación, el nombre está restringido a los caracteres
alfanuméricos más guiones bajos y a una longitud entre 8 y 20 caracteres
(modifique estas reglas según sea necesario).
if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches))
{
$result = mysql_query("SELECT * FROM CUSTOMERS
WHERE name = $matches[0]");
} else {
echo "user name not accepted";
}
Para demostrar el problema, considere este extracto:
// supposed input
$name = "Qadir'; DELETE FROM CUSTOMERS;";
mysql_query("SELECT * FROM CUSTOMSRS WHERE name='{$name}'");
Se supone que la llamada a la función recupera un registro de la tabla
CLIENTES donde la columna de nombre coincide con el nombre especificado
por el usuario. En circunstancias normales, $ name solo contendría caracteres
alfanuméricos y quizás espacios, como la cadena ilia. Pero aquí, al agregar
una consulta completamente nueva a $ name, la llamada a la base de datos
se convierte en un desastre; la consulta DELETE inyectada elimina todos los
registros de la tabla CLIENTES.
Afortunadamente, si usa MySQL, la función mysql_query () no permite el
apilamiento de consultas o la ejecución de múltiples consultas SQL en una
sola llamada de función. Si intenta apilar consultas, la llamada falla.
Sin embargo, otras extensiones de la base de datos PHP,
como SQLite y PostgreSQL, realizan consultas apiladas, ejecutan todas las
consultas proporcionadas en una cadena y crean un serio problema de
seguridad.
Prevención de inyección SQL

Puede manejar todos los caracteres de escape de forma inteligente en
lenguajes de script como PERL y PHP. La extensión MySQL para PHP
proporciona la función mysql_real_escape_string () para escapar de los
caracteres de entrada que son especiales para MySQL.
if (get_magic_quotes_gpc()) {
$name = stripslashes($name);
}
$name = mysql_real_escape_string($name);
mysql_query("SELECT * FROM CUSTOMERS WHERE name='{$name}'");
El dilema COMO
Para abordar el dilema LIKE, un mecanismo de escape personalizado debe

convertir los caracteres '%' y '_' proporcionados por el usuario en
literales. Use addcslashes () , una función que le permite especificar un rango
de caracteres para escapar.
$sub = addcslashes(mysql_real_escape_string("%str"), "%_");
// $sub == \%str\_
mysql_query("SELECT * FROM messages
WHERE subject LIKE '{$sub}%'");
SQL - Ajuste de base de datos

Lleva tiempo convertirse en un experto en bases de datos o en un
administrador experto de bases de datos. Todo esto viene con mucha
experiencia en varios diseños de bases de datos y buenos entrenamientos.
Pero la siguiente lista puede ser útil para que los principiantes tengan un buen
rendimiento de la base de datos:
 Utilice el diseño de la base de datos 3BNF explicado en este tutorial en el capítulo
Conceptos de RDBMS.
 Evite las conversiones de número a carácter porque los números y los caracteres
se comparan de manera diferente y conducen a una disminución en el
rendimiento.
 Mientras usa la instrucción SELECT, solo obtenga la información requerida y evite
usar * en sus consultas SELECT porque cargaría el sistema innecesariamente.
 Cree sus índices cuidadosamente en todas las tablas donde tiene operaciones de
búsqueda frecuentes. Evite el índice en las tablas donde tiene menos operaciones
de búsqueda y más operaciones de inserción y actualización.
 Se produce una exploración de tabla completa cuando las columnas de la cláusula
WHERE no tienen un índice asociado. Puede evitar una exploración de tabla
completa creando un índice en columnas que se usan como condiciones en la
cláusula WHERE de una instrucción SQL.
 Tenga mucho cuidado con los operadores de igualdad con números reales y
valores de fecha / hora. Ambos pueden tener pequeñas diferencias que no son
obvias a la vista pero que hacen imposible una coincidencia exacta, evitando así
que sus consultas devuelvan filas.
 Utilice el patrón de coincidencia juiciosamente. LIKE COL% es una condición
válida de WHERE, que reduce el conjunto devuelto a solo aquellos registros con
datos que comienzan con la cadena COL. Sin embargo, COL% Y no reduce aún
más el conjunto de resultados devueltos ya que% Y no se puede evaluar de
manera efectiva. El esfuerzo para hacer la evaluación es demasiado grande para
ser considerado. En este caso, se utiliza el% COL, pero el% Y se descarta. Por la
misma razón, un comodín líder% COL evita efectivamente que se use todo el
filtro.
 Afine sus consultas SQL examinando la estructura de las consultas (y
subconsultas), la sintaxis SQL, para descubrir si ha diseñado sus tablas para
admitir la manipulación rápida de datos y ha escrito la consulta de manera óptima,
permitiendo que su DBMS manipule los datos de manera eficiente .
 Para las consultas que se ejecutan regularmente, intente utilizar los
procedimientos. Un procedimiento es un grupo potencialmente grande de
sentencias SQL. Los procedimientos son compilados por el motor de la base de
datos y luego ejecutados. A diferencia de una instrucción SQL, el motor de la
base de datos no necesita optimizar el procedimiento antes de ejecutarlo.
 Evite usar el operador lógico O en una consulta si es posible. O inevitablemente
ralentiza casi cualquier consulta en una tabla de tamaño considerable.
 Puede optimizar las cargas de datos a granel soltando índices. Imagine la tabla de
historial con muchos miles de filas. Es probable que esa tabla de historial también
tenga uno o más índices. Cuando piensa en un índice, normalmente piensa en un
acceso más rápido a la tabla, pero en el caso de las cargas por lotes, puede
beneficiarse al descartar los índices.
 Cuando realice transacciones por lotes, realice COMMIT después de crear un
buen número de registros en lugar de crearlos después de cada creación de
registros.
 Planifique desfragmentar la base de datos de forma regular, incluso si hacerlo
significa desarrollar una rutina semanal.
Herramientas de ajuste incorporadas

Oracle tiene muchas herramientas para administrar el rendimiento de las
sentencias SQL, pero entre ellas dos son muy populares. Estas dos
herramientas son:
 Explicar el plan : la herramienta identifica la ruta de acceso que se tomará
cuando se ejecute la instrucción SQL.
 tkprof : mide el rendimiento por tiempo transcurrido durante cada fase del
procesamiento de sentencias SQL.
Si desea simplemente medir el tiempo transcurrido de una consulta en Oracle,
puede usar el comando SQL * Plus SET TIMING ON.
Consulte la documentación de RDBMS para obtener más detalles sobre las
herramientas mencionadas y la desfragmentación de la base de datos.

SQL

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

SQL

Cargado por

Copyright:

Formatos disponibles

Contenido

 MS SQL Server usando T-SQL,

¿Por qué SQL?

Una breve historia de SQL

DDL - Lenguaje de definición de datos

DML - Lenguaje de manipulación de datos

SQL - Conceptos RDBMS

¿Qué es una mesa?

Síguenos en Instagram para que estés al tanto de los

Un registro es una entidad horizontal en una tabla.

¿Qué es una columna?

¿Qué es un valor NULL?

Integridad de los datos

Normalización de base de datos

 Primera forma normal (1NF)

SQL - Bases de datos RDBMS

 Desarrollo de MySQL por Michael Widenius y David Axmark a partir de 1994.

 1987 - Sybase lanza SQL Server para UNIX.

Oracle comenzó en 1977 y celebró sus 32 años maravillosos en la industria

 Los usuarios pueden crear tablas, consultas, formularios e informes y conectarlos

Varios sintaxis en SQL

Sentencia SQL SELECT

SELECT column1, column2....columnN

Cláusula DISTINCT de SQL

SELECT DISTINCT column1, column2....columnN

Cláusula WHERE WHERE

SELECT column1, column2....columnN

SELECT column1, column2....columnN

SELECT column1, column2....columnN

Cláusula SQL ENTRE

SELECT column1, column2....columnN

Cláusula LIKE de SQL

Cláusula SQL ORDER BY

Cláusula SQL GROUP BY

Cláusula SQL COUNT

Cláusula HAVING de SQL

Sentencia SQL CREATE TABLE

CREATE TABLE table_name(

Sentencia SQL DROP TABLE

DROP TABLE table_name;

Sentencia SQL CREATE INDEX

Sentencia SQL DROP INDEX

Declaración SQL DESC

Sentencia SQL TRUNCATE TABLE

Sentencia SQL ALTER TABLE

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name

Sentencia SQL ALTER TABLE (Cambiar nombre)

ALTER TABLE table_name RENAME TO new_table_name;

Sentencia SQL INSERT INTO

Declaración de ACTUALIZACIÓN de SQL

Sentencia DELETE de SQL

Sentencia SQL CREATE DATABASE

Sentencia SQL DROP DATABASE

DROP DATABASE database_name;

Declaración de uso de SQL

Sentencia SQL COMMIT

Sentencia SQL ROLLBACK

Tipos de datos numéricos exactos

Empezando -9,223,372,036,854,775,808 9.223.372.036.854.775.807

letra pequeña -32,768 32,767

dinero -922,337,203,685,477.5808 +922,337,203,685,477.5807

poco dinero -214,748.3648 +214,748.3647

Tipos de datos numéricos aproximados

flotador -1.79E + 308 1.79E + 308