MySQL/Gestión/Texto completo
Métodos de acceso a la base de datos[editar]
MySQL/Gestión/Métodos de acceso a la base de datos
Lenguajes de consulta y extracción de datos[editar]
Definición[editar]
Se conoce Lenguaje de consulta o interrogación a aquel lenguaje informático que utiliza el usuario para recuperación o extracción de datos. Están dentro de la capa superior de lenguajes de programación.
Tipos[editar]
Pueden clasificarse en dos grandes grupos:
- Lenguajes no procedurales: El usuario describe la información que quiere recuperar sin determinar el tipo de órdenes que serán pertinentes para si extracción en la base de datos.
- Lenguajes procedurales o procedimentales: El usuario da órdenes para que se realicen las tareas pertinentes con el objetivo de recuperar los datos requeridos. Es la base del lenguaje de consulta SQL.
Explicación[editar]
Los lenguajes de consulta están incluidos en los SGBD[1]. Estos lenguajes permiten interrogar la base de datos. Un SGBD tiene varios componentes entre los que encontramos los de manipulación de datos. Para la comunicación entre el SGBD1 y el lenguaje de manipulación de datos necesitamos un interface adecuado que procese las expresiones del lenguaje, como pueden ser SQL, OQL, HTSQL, entre otros...
SQL[editar]
SQL quiere decir Lenguaje Estructurado de Consulta. Es muy popular hoy en día dado que la mayoría de páginas web las usan como bases de datos. Fue desarrollado a mitades de los años 70 por IBM para el prototipo de modelo relacional conocido como DBMS en las instalaciones de San José, en Estados Unidos. Más tarde, en los años 80, pasó a ser conocido como SEQUEL[2] y finalmente acabaría llamándose SQL.
Tipos de Datos[editar]
| Nombre | Descripción |
|---|---|
| CHAR(n) | Indica el número total de espacios o caracteres que ocupa la información.
En el caso de que el usuario introduzca menos caracteres del número total, automáticamente serán rellenados con espacios. |
| VARCHAR(n) | Similar al CHAR. La diferencia está en que este tipo de datos, no rellena con
espacios, de forma que se ahorra espacio. |
| DATE | Incluye los datos de Fecha. En SQL se escribe dentro de la opción DATE-TIME. |
| DECIMAL(p,q) | El sistema guardará un número decimal de "p" dígitos de longitud, mientras que
"q" será el número de decimales que tendrá ese valor. |
| INT | Valores números que se usan para poder hacer cálculos. Si posee el atributo
AUTO_INCREMENT crearemos una columna que generará un nuevo número en orden secuencial en cada nueva fila de la nueva columna. |
| SMALLINT | Similar a INT, pero es recomendable usarlo cuando tenemos la certeza que no
necesitaremos almacenar más de 33.000 apróximadamente*. |
| VALORES NULO | SQL genera un valor especial para aquellos casos en los que un dato va asociado
a otro desconocido en un momento determinado, o que nunca existirá. |
Comandos para las tablas.[editar]
A continuación, vamos a exponer los siguientes comandos para operar con tablas:
Crear una tabla:
CREATE TABLE Tabla(ColumnaA AtributosA,
ColumnaB AtributosB,
ColumnaC AtributosC;)
//De esta forma conseguiremos crear una tabla llamada "Tabla", y sus columnas con sus atributos.
Borrar una tabla:
DROP TABLE Tabla CASCADE CONSTRAINS;
// Con el Comando "drop table" vamos a borrar la tabla llamada "Tabla" y con las palabras
"cascade constrains" definimos que primero deben borrarse las restricciones de la tabla que
deseamos antes que la propia tabla haciendo posible la eliminación de la tabla maestra.
Insertar una Tabla:
INSERT INTO Tabla (columnaA, ColumnaB, ColumnaC) VALUES ('DatoA','DatoB','DatoC');
//Con "insert into" insertaremos un dato en la tabla que especifiquemos.
"values" introduce los valores "Datos" en las "Columnas".
Ver datos en una tabla:
SELECT * FROM Tabla;
//"select" equivale a "seleccionaremos", "*" equivale a todo el contenido dentro de la tabla.
"from" quiere decir "desde" y por último la Tabla, que será el nombre de la tabla desde donde
queremos ver los datos.
Corregir errores en una tabla:
UPDATE Tabla
SET ColumnaA='X'
WHERE= 'Y';
//con el comando "update" Actualizaremos el dato de la Tabla, donde antes era "y" y ahora es "X"
Como traducción a nuestro idioma entendible sería:
Actualizamos Tabla (update)
Poner(SET) en columnaA='X'
Donde existe(WHERE) = 'Y';
Eliminar una fila de una tabla:
DELETE FROM Tabla
WHERE 'ColumnaA' = 'X';
//"delete" borrará los datos que se marquen en la sintasis de la operación.
Esto quiere decir... Se borrará(delete) la fila de la tabla (from Tabla)
donde(where) en columnaA Esté el Valor X.
Ver columnas de una tabla:
DESCRIBE Tabla;
DESC Tabla;
// Cualquiera de las 2 son válidas, ambas mostrarán las columnas de las tablas que les indiquemos.
Para poder ver las columnas de una tabla en SQL, usaremos los siguientes comandos:
- sp_columns: Para listar todas las columnas de una tabla.
- Exec sp_columns "nombredetabla"·: Para listar todos los datos de la columna "nombredetabla"
Generar Informes[editar]
Podemos generar informes tanto con el documentador, como con los resultados de las consulltas. Podemos diseñar el informe de tal manera, que sea
de agradable vista para la posterior presentación. Todas las modificaciones disponibles que podemos realizar se dividen por parámetros y comandos:
Parámetros:[editar]
- SET LINESIZE: Número máximo de caracteres por línea.
- SET PAGESIZE: Numero de filas de la salida antes de empezar una nueva página.
- SET HEADING [ON|OFF]: Activa o desactiva la utilización de encabezados de columnas. Por defecto estará activado.
- SET NULL texto: Indica la cadena de caracteres que hay que colocar en sustitución de los valores NULL. Por defecto es "".
- SET ECHO[ON|OFF] Activa o desactiva la visualización de los comandos que SQL ejecuta según van siendo tratados. Por defecto estará desactivada.
- SET FEEDBACK [n|ON|OFF]: Muestra el número de registros recuperados en cada consulta cuando se recuperan "n" o más registros.
- SET VERIFY [ON|OFF]: Controla la salida de confirmación para los valores de las variables de sustitución.
Comandos:[editar]
- TTITLE: Formación del encabezado de página.
- BTITLE: Formación del pie de página.
- COLUMN: Formatear cada columna.
- BREAK: Puntos de ruptura en los listados.
- COMPUTE: Realizar cálculos con columnas.
Para sustituir una variable usaremos el comando "define".
DEFINE TABLA=TABLA2
Cláusula SELECT[editar]
Es la función más importante de un SGBD1. Su sintaxis de forma general es la siguiente:
SELECT Columna
FROM Tabla
WHERE Condición
ORDER BY ExpresiónColumna;
Si introducimos SELECT * "*" quiere decir que seleccionaremos todo.
"WHERE" dispone de los siguientes operadores :
| OPERADOR DE CADENA DE CARACTERES | OPERACIÓN |
|---|---|
| || | Concatenación |
| OPERADORES ARITMÉTICOS | OPERACIÓN |
|---|---|
| + | Suma |
| - | Resta |
| * | Producto |
| / | División |
| OPERADORES DE COMPARACIÓN | OPERACIÓN |
|---|---|
| = | Igualdad |
| < | Menor que |
| > | Mayor que |
| <= | Menor o igual que |
| >= | Mayor o igual que |
| in | Igual a cualquiera de los miembros del paréntesis |
| not in | Distinto a cualquiera de los miembros del paréntesis |
| between | Contenido en el rango |
| not between | Fuera del rango |
| like '_abc%' | Contiene la cadena indicada "abc" a partir del segundo
carácter y luego cualquier cadena de caracteres |
| != | Distinto a |
| months between (d1,d2) | Devuelve la diferencia en meses entre 2 fechas |
| OPERADORES BOOLEANOS | OPERACIÓN |
|---|---|
| AND | Intersección |
| OR | Unión |
| NOT | No |
Operador Like[editar]
Este operador ayuda a la recuperación de información compleja. Sirve para condiciones donde el resultado a recuperar no sea exacto.
Usando este operador, buscaremos coincidencias( no necesariamente exactas) por aproximación.
La forma de representarlo sería la siguiente:
SELECT Columna
FROM Tabla
WHERE Condición LIKE '%X%';
Cláusula Order by[editar]
Esta cláusula ordena los datos de forma previa a la visualización por usuarios o de su impresión.
Nuestro sistema ordenará los valores por defecto, pero si los queremos ordenar de alguna forma expresa usaremos Order by.
El modo de empleo de esta cláusula será la siguiente:
SELECT Columna,Dinero.
FROM Tabla
ORDER BY Dinero DESC;
//ASC significará de forma ascendente, mientras que DESC todo lo contrario, de forma descendente.
Funciones de Agregación[editar]
Son usadas por SQL. Se usan para hallar valores máximos, mínimos, calcular datos,etc...
Se aplican a grupos de filas llegándose a aplicar a todas las filas de una tabla si es necesario.
Las funciones serán las siguientes:
- COUNT: Cuenta el número de filas de una tabla
- SUM: Suma la cantidad de las filas que le concretemos.
- AVG: Obtiene el valor medio en un rango.
- Max: Obtiene el valor máximo de un rango.
- Min: Obtiene el valor mínimo de un rango.
Cláusulas Group by, Order by y Where/Having[editar]
Crean un conjunto de filas que comparten una misma característica:
- Group by: Para agrupar un número de filas y sobre este conjunto realizar una operación.
- Order by: Para ordenar un número de filas, y sobre estos poder realizar operaciones.
- Where/Having: Si Where limita las características, Having limita los grupos.
Consulta a múltiples tablas[editar]
Para poder realizar consultas en varias tablas, SQL cuenta con los operadores algebraicos avanzados:
- INTERSECT: Reúne varios conjuntos en uno solo.
- MINUS: Realiza una división entre los conjuntos.
- AND: Realiza una intersección entre los conjuntos.
- ALL & ANY: extraen datos de una subconsulta tras unir 2 tablas y crean una sola columna numérica.
Referencias[editar]
Lenguaje de definición de datos[editar]
El Lenguaje de definición de datos (Data Definition Language o DDL) es un lenguaje proporcionado por el SGBD cuya finalidad es la definición de las estructuras que almacenarán los datos así como de los procedimientos o funciones que permitan consultarlos (aunque en algunos casos los SGBD la descripción a nivel físico sera realizada por el Lenguaje de Definición de Almacenamiento de datos o DSDL) y la manipulación de datos almacenados en SGBD relacionales. Con este lenguaje, con cada sentencia se crea, define o elimina datos. Utiliza como base los fundamentos matemáticos del álgebra relacional y sentencias formadas con verbos.
- Sentencias de definición de datos
- Sentencias de manipulación de datos
- Sentencias de concesión y revocación de privilegios
- Procedimientos almacenados
- Disparadores
Sentencias de definición de datos[editar]
Cada sentencia, ecuación o consulta se encuentra formada por un verbo seguido por clausulas, comandos, funciones y, opcionalmente, expresiones.
Sintaxis de una sentencia[editar]
SELECT columna1, columna2, columna3 FROM nombre_de_la_tabla
CREATE TABLE ‘Alumno’ ( Dni int, Nombre, VARCHAR(100), Apellidos, VARCHAR(200), Curso CHAR (50), CONSTRAINT PK_alumno PRIMARY KEY (Dni), CONSTRAINT FK_alumno_curso FOREIGN KEY (Curso) REFERENCES (Curso) )
En los ejemplos se ilustra como utilizamos mayúsculas para denotar las acciones que queremos que se cumplan.
Lista de comandos básicos[editar]
Los comandos que se pueden utilizar para la selección son:
| Comando | Función |
|---|---|
| SELECT | Recupera el dato especificado |
| SELECT ALL | Recupera todos los datos o tablas |
| SELECT DISTINCT | Recupera datos con características distintas |
| FROM | Delimita una búsqueda --desde-- un punto |
| WHERE | Delimita una búsqueda en una localización |
Los comandos que se pueden utilizar para modificar, borrar o definir tablas son
| Comando | Función | Ejemplo |
|---|---|---|
| CREATE | Permite la creación de nuevos objetos o vistas | CREATE TABLE 'Ejemplo' |
| ALTER | Permite la modificación de la estructura de un objeto | ALTER TABLE 'Ejemplo' ADD SUELDO INT UNSIGNED |
| DROP | Permite eliminar un objeto de la BD | DROP TABLE 'Ejemplo' |
| TRUNCATE | Permite eliminar todos los datos que contiene una tabla | TRUNCATE 'Ejemplo' |
Por ejemplo, utilizando el DDL podremos crear una vista nueva utilizando el comando CREATE VIEW seguido por la consulta que deseamos realizar.
CREATE VIEW Nombreedades AS
SELECT Nombre, apellidos, edad FROM Alumnos;
Sentencias de manipulación de datos[editar]
Los usuarios utilizan el Lenguaje de Manipulación de Datos o DML para consultar o manipular la información y organizarla según el modelo de datos más adecuado.
| Comando | Función |
|---|---|
| SELECT | Comando que queremos ejecutar |
| ALL | Selecciona todos los datos |
| DISTINCT | Selecciona valores distintos |
| FROM | Marca las tablas donde se realizará la consulta |
| WHERE | Nos permite realizar consultas con condiciones |
| GROUP BY | Define la agrupación que se le da a los datos |
| HAVING | Define una condición que se debe cumplir para que los datos sean devueltos en la busqueda |
| ORDER BY | Define el order en que se visualizan los datos (ASC / DESC) |
| INSERT | Agrega uno o más registros a una tabla en una BD relacional |
| UPDATE | Modifica los valores de un conjunto de registros |
| DELETE | Borra uno o más registros de una tabla |
Sentencias de concesión y revocación de privilegios[editar]
Garantizan la prevención de accesos no autorizados y la integridad de una BD.
El administrar del sistema debe determinar los niveles de acceso que necesitan los distintos tipos de usuarios, y esto se consigue en SQL mediante los comandos GRANT y REVOKE, que nos permitirán otorgar y retirar privilegios respectivamente. Entre los privilegios que podemos modificar se encuentran los comandos SELECT, UPDATE, DELETE, INSERT.
Por defecto, un usuario al que se le conceden privilegios no tiene derecho a reotorgarlos a un tercero. Para poder permitir esta opción, tendremos que agregar el comando WITH GRANT OPTION cuando otorguemos los privilegios. Si posteriormente utilizamos el comando REVOKE en el primer usuario, REVOKE también sera utilizado en cualquier otro usuario al que este le haya conferido privilegios.
Procedimientos almacenados[editar]
MySQL/Gestión/Lenguaje de definición de datos/Procedimientos almacenados
Disparadores[editar]
MySQL/Gestión/Lenguaje de definición de datos/Disparadores
Lenguaje de manipulación de datos[editar]
El lenguaje de manipulación de datos (Data Manipulation Language, o DML) es un lenguaje de programación que se utiliza para la definición del nivel externo y las operaciones de manipulación de la información.
La definición del nivel externo de representación consiste en la definición de vistas de los datos que utilizarán los usuarios de la base de datos.
La manipulación de los datos consiste en la realización de operaciones de inserción, borrado, modificación y consulta de la información almacenada en la base de datos. La inserción y el borrado son el resultado de añadir nueva información a la ya que se encontraba almacenada o eliminarla de nuestra base de datos, tomando en cuenta las restricciones marcadas por el DDL y las relaciones entre la nueva información y la antigua. La modificación nos permite alterar esta información, y la consulta nos permite el acceso a la información almacenada en la base de datos siguiendo criterios específicos.
El DML de un SGBD dependerá del tipo de modelo lógico de datos que se utilice en cada caso: Un SGBD jerárquico o de red, que poseen un modelo lógico basado en registros y sus relaciones, utilizará un DML con un nivel de abstracción menos complejo que el que sería utilizado en un SGBD relacional, y se usarían punteros y registros. Una operación en este SGBD tendrá dos componentes diferenciados: una primera fase de acceso cuyo objeto es el situar los punteros para seleccionar correctamente el registro a manipular, y una segunda fase que consiste en describir la operación deseada. El DML en un SGBD relacional utilizaran tablas y para el acceso a la información se utiliza el cálculo relacional y el álgebra relacional. El cálculo relacional puede estar orientado a tuplas u orientado a dominios:
| Acceso | Sintaxis |
|---|---|
| Orientado a tuplas | p(t)} |
| Orientado a dominios | P(X1,X2,...Xn)} |
Donde t representa una tabla o relación y p(t) es un predicado sobre ella. Donde X1..Xn represente una serie de variables de dominio y P es un predicado.
El álgebra relacional propone una serie de operadores (Unión, diferencia, selección, proyección y producto cartesiano y adicionales operadores de nivel avanzado) que pueden ser aplicados a una o varias relaciones y devolver una relación con características distintas a las anteriores.
La sentencia SELECT[editar]
Seleccionar Registros
SELECT FROM nombre_de_tabla WHERE condición;
nombre_de_tabla: La tabla que queramos.
condición: La condición que han de cumplir los registros.
Ejemplo: Seleccionar a los alumnos de cuarto.
SELECT nombre,apellidos FROM alumnos WHERE curso=4;
Lenguajes de consulta[editar]
MySQL/Gestión/Lenguajes de consulta
JPQL[editar]
JPQL (Java Persistence Query Language)[editar]
Es un lenguaje de consulta independiente de plataforma orientado a objetos definidos como parte la especificación Java Persistence API. Nos permite definir consultas SQL dentro de un contexto JPA. Se caracteriza por hacer consultas en entidades almacenadas en bases de datos relacionales. La gran diferencia con SQL es que operan contra objetos entidad JPA (Bases de datos diseñadas en Java) en lugar de hacerlo directamente con las tablas de bases de datos.
Aunque no maneja el lenguaje JPQL debemos mencionar las JPA Query API utilizadas para consultas estáticas (inmodificables) y dinámicas (modificables). Utilizadas para usar interfaces, anotaciones, métodos. JPA Query API comprate con JPQL el entorno de desarrollo en Java, pero son independientes.
JPQL está desarrollado a partir de HQL (Hibernate Query Language). Hibernate y HQL se crearon antes de la especificación Java (JPA). Todas las consultas en HQL son válidas en JPQL aunque no a la inversa.
Mayúsculas y minúsculas en JPQL[editar]
Salvo en contadas ocasiones, JPQL no es sensible a mayúsculas o minúsculas. Las palabras claves o comandos pueden escribirse de ambas formas (SELECT o select; UPDATE o update; DELETE o delete). Donde sí es necesario distinguir entre minúsculas y mayúsculas es cuando JPQL incluye elementos de la fuente, elementos Java, como nombres de entidades, clases y campos persistentes que deben escribirse siempre distinguiendo entre mayúsculas y minúsculas.
Lista de palabras o identificadores reservados[editar]
Cuando utilizamos JPQL tendremos en cuenta el listado de palabras reservadas. Son un número de identificadores que no pueden ser utilizados libremente. Pueden interferir en la programación Java. También a la extracción de datos de forma óptima. Las palabras reservadas se obian del sistema para evitar riesgos ya expuestos, estás palabras no existen en la Base de Datos.
Lista de palabras: ABS, ALL, AND, ANY, AS, ASC, AVG, BEETWEEN, BIT_LENGTH, BOTH, BY, CASE, CHAR_LENGTH, CHARACTER_LENGHT, CLASS, COALESCE, CONCAT, COUNT, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP, DELETE, DESC, DISTINCT, ELSE, EMPTY, END, ENTRY, ESCAPE, EXISTS, FALSE, FETCH, FROM, GROUP, HAVING, IN, INDEX, INNER, IS, JOIN, KEY, LEADING, LEFT, LENGTH, LIKE, LOCATE, LOWER, MAX, MEMBER, MIN, MOD, NEW, NOT, NULL, NULLIF, OBJETCT, OF, OR, ORDER, OUTER, POSITION, SELECT, SET, SIZE, SOME, SQRT, SUBSTRING, SUM, THEN, TRAILING, TRIM, TRUE, TYPE, UNKNON, UPDATE, UPPER, VALUE, WHEN, WHERER.
Comandos JPQL: SELECT, DELETE, UPDATE[editar]
Sintaxis JPQL es muy similar a la sintaxis de SQL. Tener SQL como sintaxis es una ventaja porque SQL es simple y siendo ampliamente utilizado.
Por ejemplo, una consulta JPQL puede recuperar una entidad objeto en lugar de campo conjunto de resultados de una base de datos, al igual que con SQL. El JPQL consulta estructura de la siguiente forma:
SELECT ... FROM ... [WHERE ...] [GROUP BY ... [HAVING ...]] [ORDER BY ...]
La estructura de JPQL borrar DELETE y modificado UPDATE
DELETE FROM ... [WHERE ...] UPDATE ... SET ... [WHERE ...]
Ejecutar sentencias JQPL[editar]
Una vez que hemos visto como montar y crear sentencias JPQL llega el momento de lanzarlas. Dado que lo tenemos que hacer dentro de un programa Java es necesario usar una serie de métodos y pasos para poder hacerlo.
El lenguaje JPQL se integra implementado la interface “Query”. Esta implementación se obtiene a través de “EntityManager”. Se usan diversos métodos de factoría, entre los que destacan los siguientes:
- createQuery(String jpql)
- createNamedQuery(String name)
- createNativeQuery(String sql)
Insertar atributos o sentencias[editar]
Se hace mediante INSERT_STATEMENT
Sintaxis:
insert_statement ::= insert_clause select_statement
insert_clause ::= INSERT INTO entity_name (atribute_list)
atribute_list ::= state_field[, state_field]*
Funciones de agregación[editar]
La semántica es la misma que en SQL. En JPQL son:
- COUNT: cuenta el número de filas de una tabla.
- AVG: Recupera el valor medio de un rango. Los valores recuperados dependerán.
- MIN: Recupera el mínimo de un rango.
- MAX: Recupera el máximo de un rango.
- SUM: Suma los valores.
Funciones normalizadas[editar]
- CONCAT: Función de concretar cadenas.
- SUBSTRING: Recupera un extracto del valor encadenado.
- UPER: Convierte un Upper cases la cadena especificada.
- LOWER: Convierte en Lower cases la cadena especificada.
- TRIM: La función TRIM sigue la semántica de SQL.
- LENGTH: Recupera la longitud de la cadena.
- LOCATE: Localiza una cadena con otra cadena.
- ABS: Calcula el valor absolute de un cálconumérico.
- MOD: Calcula el resultado de dividir el primer número o argumento por el segundo.
- SQRT: Recupera la raíz cuadrada de un valor numérico.
- CURRENT_DATE: Devuelve el número de datos que contiene una base de datos.
- CURRENT_TIME: Devuelve la hora actual de la base de datos.
- LIKE: Se aplica a la extracción de cadenas de datos.
Otros comandos que JPQL comparte con SQL[editar]
- BEETWEN: Al igual que SQL recupera el cálculo entre dos valores dados (deben ser comparables).
- IN: marca el lugar donde debemos realizar la búsqueda.
Operadores booleanos[editar]
- NOT: Niega el predicado que le sigue.
- AND: Combina la expresión que le precede con la que le sucede. Se dará cuando los dos predicados sean ciertos.
- OR: Igualmente a AND combina dos expresiones.
- WHERE: Marca o restringe los resultados obtenidos en función de la ecuación que sigue Where. Es importante para limitar las actualizaciones y las eliminaciones de datos.
- GROUP BY: Agrupamiento como SQL.
- HAVING: Restringe los resultados obtenidos como WHERE pero opera en valores agregados.
- ORDER BY: ordena los valores recuperados según el criterio que le indiquemos.
XMLQL[editar]
XMLQL[editar]
XML siglas en inglés de eXtensible Markup Language, traducido como "Lenguaje de Marcado Extensible" o "Lenguaje de Marcas Extensible", es un meta-lenguaje que permite definir lenguajes de marcas desarrollado por el World Wide Web Consortium (W3C) utilizado para almacenar datos en forma legible. Proviene del lenguaje SGML y permite definir la gramática de lenguajes específicos (de la misma manera que HTML es a su vez un lenguaje definido por SGML) para estructurar documentos grandes. A diferencia de otros lenguajes, XML da soporte a bases de datos, siendo útil cuando varias aplicaciones deben comunicarse entre sí o integrar información.
XML no ha nacido únicamente para su aplicación en Internet, sino que se propone como un estándar para el intercambio de información estructurada entre diferentes plataformas. Se puede usar en bases de datos, editores de texto, hojas de cálculo y casi cualquier cosa imaginable.
XML es una tecnología sencilla que tiene a su alrededor otras que la complementan y la hacen mucho más grande, con unas posibilidades mucho mayores. Tiene un papel muy importante en la actualidad ya que permite la compatibilidad entre sistemas para compartir la información de una manera segura, fiable y fácil.
XML/SQL es una serie de módulos relacionados con XML-related para el lenguaje de consulta de base de datos SQL. Se usa el tipo XML como un tipo de columna al crear una tabla, como un tipo de variable, como un tipo de parámetro y un tipo de valor devuelto en función. La utilización es del tipo de lenguaje de consulta XQuery
Consulta[editar]
Una consulta SELECT devuelve los resultados como un conjunto de filas. Opcionalmente, se pueden recuperar resultados formales de una consulta SQL como XML especificando la cláusula FOR XML en la consulta. La cláusula FOR XML puede usarse en consultas de nivel superior y en subconsultas. La cláusula FOR XML de nivel superior solo puede usarse en la instrucción SELECT. En el caso de las subconsultas, FOR XML puede usarse en las instrucciones INSERT, UPDATE y DELETE. También puede usarse en instrucciones de asignación.
En una cláusula FOR XML se especifica uno de estos modos:
- RAW
- AUTO
- EXPLICIT
- PATH
El modo RAW genera un único elemento <row> por cada fila del conjunto de filas devuelto por la instrucción SELECT. Para generar una jerarquía XML se pueden escribir consultas FOR XML anidadas.
El modo AUTO genera anidamiento en el XML resultante utilizando heurística basada en la forma en que se especifica la instrucción SELECT. El control sobre la forma del XML generado es mínimo. Es posible escribir consultas FOR XML anidadas para generar una jerarquía XML más allá de la forma del XML generado mediante la heurística del modo AUTO.
El modo EXPLICIT concede un mayor control de la forma del XML. Es posible mezclar atributos y elementos con total libertad para decidir la forma del XML. Requiere un formato específico para el conjunto de filas resultante generado debido a la ejecución de la consulta. Después, el formato del conjunto de filas se asigna a una forma de XML. La eficacia del modo EXPLICIT reside en que se pueden mezclar atributos y elementos con total libertad, crear contenedores y propiedades complejas anidadas, crear valores separados por espacios (por ejemplo, el atributo OrderID puede tener una lista de valores de Id. de orden) y contenido mezclado.
Sin embargo, escribir consultas con el modo EXPLICIT puede ser un proceso complejo. Se pueden utilizar algunas de las características nuevas de FOR XML, como la posibilidad de escribir consultas anidadas FOR XML en modo RAW/AUTO/PATH y la directiva TYPE, en lugar de utilizar el modo EXPLICIT para generar las jerarquías. Las consultas FOR XML anidadas pueden generar el mismo XML que el modo EXPLICIT. Para obtener más información, vea Usar consultas FOR XML anidadas y Directiva TYPE en consultas FOR XML.
El modo PATH, junto con la característica de las consultas anidadas FOR XML, proporciona la flexibilidad del modo EXPLICIT de una manera más sencilla.
Estos modos solamente tienen efecto en la ejecución de la consulta para la que se configuraron. No afectan a los resultados de ninguna de las consultas posteriores.
La cláusula FOR XML no es válida en una selección que se use junto con una cláusula FOR BROWSE.
Ejemplo[editar]
La siguiente instrucción SELECT recupera información de las tablas Sales.Customer y Sales.SalesOrderHeader de la base de datos AdventureWorks2012 . Esta consulta especifica el modo AUTO en la cláusula FOR XML :
USE AdventureWorks2012
GO
SELECT Cust.CustomerID,
OrderHeader.CustomerID,
OrderHeader.SalesOrderID,
OrderHeader.Status
FROM Sales.Customer Cust
INNER JOIN Sales.SalesOrderHeader OrderHeader
ON Cust.CustomerID = OrderHeader.CustomerID
FOR XML AUTO
La cláusula FOR XML y nombres de servidor[editar]
Cuando una instrucción SELECT con una cláusula FOR XML especifica un nombre de cuatro partes en la consulta, el nombre de servidor no se devuelve en el documento XML resultante cuando la consulta se ejecuta en el equipo local. Sin embargo, el nombre del servidor se devuelve como un nombre de cuatro partes cuando la consulta se ejecuta en un servidor de red.
Por ejemplo, considere esta consulta:
SELECT TOP 1 LastName FROM ServerName.AdventureWorks2012.Person.Person FOR XML AUTO
Cuando ServerName es un servidor local, la consulta devuelve lo siguiente:
<AdventureWorks2012.Person.Person LastName="Achong" />
Cuando ServerName es un servidor de red, la consulta devuelve lo siguiente:
<ServerName.AdventureWorks2012.Person.Person LastName="Achong" />
Se puede evitar esta ambigüedad especificando este alias:
SELECT TOP 1 LastName FROM ServerName.AdventureWorks2012.Person.Person x FOR XML AUTO
Esta consulta devuelve lo siguiente:
<x LastName="Achong"/>
HTSQL[editar]
HTSQL (Hyper-Text Structured Query Languaje)[editar]
Es un estándar que transforma las preguntas de HTTP en consultas SQL además es un lenguaje de consulta completa con la vinculación automática, agregación, proyecciones, filtros, macros, una sintaxis compositiva, y un conjunto completo de funciones y tipos de datos. Extrae datos de bases relacionales y devuelve los resultados como XML, HTML, CSV, JSON, o YAML.
HTSQL está diseñado para analistas de datos y otros programadores accidentales que tienen consultas comerciales complejas para resolver y necesitan una herramienta productiva para escribir y compartir consultas de bases de datos.
HTSQL soporta diferentes dialectos SQL incluyendo SQLite, PostgreSQL, MySQL, Oracle y Microsoft SQL Server.
HTSQL es una herramienta de comunicación, se utiliza para la colaboración entre los usuarios de negocios, analistas de datos y desarrolladores de aplicaciones. HTSQL consultas pueden ser enviadas por correo electrónico, incrustado en los informes, y se incluyen en las peticiones de características
Caracteristicas[editar]
Los usuarios más comunes de HTSQL suelen ser personas que consultan a menudo los URLS de las páginas web y que aciertan de alguna manera construyendo ecuaciones de búsqueda.
- HTSQL sigue hablando de forma general, la gramática de SQL.
- Las cadenas de palabras se insertan entre ".
- Los nombres de las columnas o tablas se insertan entre "".
- Los valores numéricos no se marcan.
- A los valores que no sean alfanuméricos les precede el guión bajo (_).
- Cuando hablamos de un valor inferior lo indicamos: less-than() frente a otras formas como <.
Las expresiones del predicado:
- Emulan la forma de HTML utilizando & y =
- Se usa | para separar.
- Se usa la exclamación para negar.
- Utiliza lower().
Al igual que en SQL acepta filtar por agregados, selecciona datos de una o varias columnas. EN todos los casos la sintaxis es la misma que en SQL.
Comandos HTSQL[editar]
SELECT, INSERT, UPDATE, DELETE, WHERE, ORDER BY-
LINQL[editar]
LINQL[editar]
En C# como en la mayoría de los lenguajes de programación hay que declarar una variable antes de poder utilizarla, si no la declaramos es como si no existiera y no podríamos trabajar con ella. LINQL está basado en este lenguaje de programación. Además siempre debemos compilar y ejecutar con F5. EL primer paso para trabajar con LINQ es declarar una variable, especificando el origen de los datos. EN una consulta LINQ, la cláusula FROM aparece en primer lugar para introducir origen de los datos y la variable de rango.
Además, tiene que aprender un lenguaje de consultas diferente para cada tipo de origen de datos: bases de datos SQL, documentos XML y varios servicios web, entre otros. Con LINQ, una consulta es una construcción de lenguaje de primera clase, como clases, métodos y eventos.
Para un desarrollador que escribe consultas, la parte más visible de "lenguaje integrado" de LINQ es la expresión de consulta. Las expresiones de consulta se escriben con una sintaxis de consulta declarativa. Con la sintaxis de consulta, puede realizar operaciones de filtrado, ordenación y agrupamiento en orígenes de datos con el mínimo código. Utilice los mismos patrones de expresión de consulta básica para consultar y transformar datos de bases de datos SQL, conjuntos de datos de ADO .NET, secuencias y documentos XML y colecciones. NET.
En el ejemplo siguiente se muestra la operación de consulta completa. La operación completa incluye crear un origen de datos, definir la expresión de consulta y ejecutar la consulta en una instrucción foreach.
C#
class LINQQueryExpressions
{
static void Main()
{
// Specify the data source.
int[] scores = new int[] { 97, 92, 81, 60 };
// Define the query expression.
IEnumerable<int> scoreQuery =
from score in scores
where score > 80
select score;
// Execute the query.
foreach (int i in scoreQuery)
{
Console.Write(i + " ");
}
}
}
// Output: 97 92 81
Información general sobre la expresión de consulta[editar]
- Las expresiones de consulta se pueden utilizar para consultar y transformar los datos de cualquier origen de datos habilitado para LINQ. Por ejemplo, una sola consulta puede recuperar datos de una base de datos SQL y generar una secuencia XML como salida.
- Las expresiones de consulta son fáciles de controlar porque utilizan muchas construcciones de lenguaje C# familiares.
- Todas las variables de una expresión de consulta están fuertemente tipadas, aunque en muchos casos no es necesario proporcionar el tipo explícitamente porque el compilador puede deducirlo. Para más información, vea Type Relationships in LINQ Query Operations (Relaciones entre tipos en las operaciones de consulta LINQ).
- Una consulta no se ejecuta hasta que no se realiza la iteración a través de la variable de consulta, por ejemplo, en una instrucción
foreach. Para más información, vea Introduction to LINQ queries (Introducción a las consultas LINQ). - En tiempo de compilación, las expresiones de consulta se convierten en llamadas al método de operador de consulta estándar según las reglas establecidas en la especificación de C#. Cualquier consulta que se puede expresar con sintaxis de consulta también se puede expresar mediante sintaxis de método. Sin embargo, en la mayoría de los casos, la sintaxis de consulta es más legible y concisa. Para más información, vea Especificación del lenguaje C# e Información general sobre operadores de consulta estándar.
- Como regla al escribir consultas LINQ, se recomienda utilizar la sintaxis de consulta siempre que sea posible y la sintaxis de método cuando sea necesario. No hay diferencias semánticas ni de rendimiento entre estas dos formas diversas. Las expresiones de consulta suelen ser más legibles que las expresiones equivalentes escritas con la sintaxis de método.
- Algunas operaciones de consulta, como Count o Max, no tienen ninguna cláusula de expresión de consulta equivalente y, por tanto, deben expresarse como una llamada de método. La sintaxis de método se puede combinar con la sintaxis de consulta de varias maneras. Para más información, vea Query syntax and method syntax in LINQ (Sintaxis de consulta y sintaxis de método en LINQ).
- Las expresiones de consulta pueden compilarse en árboles de expresión o en delegados, en función del tipo al que se aplica la consulta. Las consultas IEnumerable<T> se compilan en delegados. Las consultas IQueryable y IQueryable<T> se compilan en árboles de expresión. Para más información, vea Expression trees (Árboles de expresión).
Las tres partes de una operación de consulta[editar]
Todas las operaciones de consulta LINQ constan de tres acciones distintas:
- Obtener el origen de datos.
- Crear la consulta.
- Ejecutar la consulta. En el siguiente ejemplo se muestra cómo se expresan las tres partes de una operación de consulta en código fuente. En el ejemplo se usa una matriz de enteros como origen de datos para su comodidad, aunque se aplican los mismos conceptos a otros orígenes de datos. En el resto de este tema se hará referencia a este ejemplo. C#
class IntroToLINQ { static void Main() { // The Three Parts of a LINQ Query: // 1. Data source. int[] numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 }; // 2. Query creation. // numQuery is an IEnumerable<int> var numQuery = from num in numbers where (num % 2) == 0 select num; // 3. Query execution. foreach (int num in numQuery) { Console.Write("{0,1} ", num); } } }En la siguiente ilustración se muestra toda la operación de consulta. En LINQ, la ejecución de la consulta es distinta de la propia consulta; en otras palabras, no ha recuperado los datos creando una variable de consulta.
El origen de datos[editar]
En el ejemplo anterior, como el origen de datos es una matriz, admite implícitamente la interfaz genérica IEnumerable<T>. Este hecho implica que se puede consultar con LINQ. Una consulta se ejecuta en una instrucción foreach, y foreach requiere IEnumerable o IEnumerable<T>. Los tipos que admiten IEnumerable<T> o una interfaz derivada, como la interfaz genérica IQueryable<T>, se denominan tipos consultables.
Un tipo consultable no requiere ninguna modificación ni ningún tratamiento especial para actuar como origen de datos de LINQ. Si el origen de datos no está en la memoria como tipo consultable, el proveedor de LINQ debe representarlo como tal. Por ejemplo, LINQ to XML carga un documento XML en un tipo XElement que se puede consultar:
C#
// Create a data source from an XML document.
// using System.Xml.Linq;
XElement contacts = XElement.Load(@"c:\myContactList.xml");
Con LINQ to SQL, primero se crea una asignación relacional de objetos en tiempo de diseño ya sea manualmente o mediante las herramientas de LINQ to SQL de Visual Studio. Después, se escriben las consultas en los objetos y, en tiempo de ejecución, LINQ to SQL controla la comunicación con la base de datos. En el ejemplo siguiente, Customers representa una tabla específica en la base de datos; el tipo del resultado de la consulta, IQueryable<T>, se deriva de IEnumerable<T>.
C#
Northwnd db = new Northwnd(@"c:\northwnd.mdf");
// Query for customers in London.
IQueryable<Customer> custQuery =
from cust in db.Customers
where cust.City == "London"
select cust;
Para obtener más información sobre cómo crear tipos específicos de orígenes de datos, vea la documentación de los distintos proveedores de LINQ. Aun así, la regla básica es muy sencilla: un origen de datos de LINQ es cualquier objeto que admita la interfaz genérica IEnumerable<T> o una interfaz que la haya heredado.
La consulta[editar]
La consulta especifica la información que se debe recuperar de los orígenes de datos. Opcionalmente, una consulta también especifica cómo se debe ordenar, agrupar y conformar esa información antes de que se devuelva. Las consultas se almacenan en una variable de consulta y se inicializan con una expresión de consulta. Para facilitar la escritura de consultas, C# ha incorporado una nueva sintaxis de consulta.
La consulta del ejemplo anterior devuelve todos los números pares de la matriz de enteros. La expresión de consulta contiene tres cláusulas: from, where y select (si está familiarizado con SQL, habrá observado que el orden de las cláusulas se invierte respecto al orden de SQL). La cláusula from especifica el origen de datos, la cláusula where aplica el filtro y la cláusula select especifica el tipo de los elementos devueltos. Estas y otras cláusulas de consulta se tratan con detalle en la sección Expresiones de consulta LINQ. Por ahora, lo importante es que en LINQ la variable de consulta no efectúa ninguna acción y no devuelve ningún dato. Lo único que hace es almacenar la información necesaria para generar los resultados cuando se ejecuta la consulta en algún momento posterior. Para obtener más información sobre cómo se construyen las consultas en segundo plano, vea Información general sobre operadores de consulta estándar (C#)Información general sobre operadores de consulta estándar.
Nota[editar]
Las consultas también se pueden expresar empleando una sintaxis de método. Para obtener más información, vea Query Syntax and Method Syntax in LINQ (Sintaxis de consulta y sintaxis de método en LINQ).
Ejecución de la consulta[editar]
Ejecución aplazada[editar]
Como se ha indicado anteriormente, la variable de consulta solo almacena los comandos de consulta. La ejecución real de la consulta se aplaza hasta que se procese una iteración en la variable de consulta en una instrucción foreach. Este concepto se conoce como ejecución aplazada y se muestra en el ejemplo siguiente:
C#
// Query execution.
foreach (int num in numQuery)
{
Console.Write("{0,1} ", num);
}
La instrucción foreach es también donde se recuperan los resultados de la consulta. Por ejemplo, en la consulta anterior, la variable de iteración num contiene cada valor (de uno en uno) en la secuencia devuelta.
Dado que la propia variable de consulta nunca contiene los resultados de la consulta, puede ejecutarla tantas veces como desee. Por ejemplo, se puede tener una base de datos que esté siendo actualizada de forma continua por otra aplicación. En su aplicación, se puede crear una consulta que recupere los datos más recientes y se puede ejecutar repetidamente de acuerdo con un intervalo para recuperar resultados diferentes cada vez.
Forzar la ejecución inmediata[editar]
Las consultas que llevan a cabo funciones de agregación en un intervalo de elementos de origen primero deben recorrer en iteración dichos elementos. Ejemplos de estas consultas son Count, Max, Average y First. Se ejecutan sin una instrucción foreach explícita, ya que la propia consulta debe usar foreach para poder devolver un resultado. Tenga en cuenta también que estos tipos de consultas devuelven un único valor, y no una colección IEnumerable. La consulta siguiente devuelve un recuento de los números pares de la matriz de origen:
C#
var evenNumQuery =
from num in numbers
where (num % 2) == 0
select num;
int evenNumCount = evenNumQuery.Count();
Para forzar la ejecución inmediata de cualquier consulta y almacenar los resultados en la caché, puede llamar al método ToList o ToArray.
C#
List<int> numQuery2 =
(from num in numbers
where (num % 2) == 0
select num).ToList();
// or like this:
// numQuery3 is still an int[]
var numQuery3 =
(from num in numbers
where (num % 2) == 0
select num).ToArray();
También puede forzar la ejecución colocando el bucle foreach justo después de la expresión de consulta, aunque, si se llama a ToList o a ToArray, también se almacenan en caché todos los datos de un objeto de colección.