Compartir a través de

Cómo se diferencia Entity SQL de Transact-SQL

  • Artículo

Este tema describe las diferencias entre Entity SQL y Transact-SQL .

Compatibilidad con herencia y relaciones

Entity SQL trabaja directamente con esquemas de entidades conceptuales y admite características del modelo conceptual tales como herencia y relaciones.

Cuando se trabaja con la herencia, suele ser útil seleccionar instancias de un subtipo de una colección de instancias de supertipo. El operador oftype de Entity SQL (similar a oftype de las secuencias de C#) proporciona esta capacidad.

Compatibilidad con colecciones

Entity SQL trata las colecciones como entidades de primera clase. Por ejemplo:

  • Las expresiones de colecciones son válidas en una cláusula from.

  • Las subconsultas in y exists se han generalizado para permitir cualquier tipo de colección.

    Una subconsulta es un tipo de colección. e1 in e2 y exists(e) son las construcciones de Entity SQL que permiten realizar estas operaciones.

  • Las operaciones Set, como union, intersect y except, operan ahora en colecciones.

  • Las combinaciones operan en colecciones.

Compatibilidad con expresiones

Transact-SQL tiene subconsultas (tablas) y expresiones (filas y columnas).

Para admitir colecciones y colecciones anidadas, Entity SQL convierte todo en una expresión. Entity SQL es más ajustable que Transact-SQL : todas las expresiones se puede utilizar en cualquier parte. Las expresiones de consulta siempre producen colecciones de los tipos proyectados y se pueden utilizar en cualquier parte donde se permita una expresión de colección. Para obtener información sobre las expresiones de Transact-SQL que no se admiten en Entity SQL , vea Expresiones no admitidas (Entity SQL).

A continuación se muestran consultas válidas de Entity SQL :

1+2 *3
"abc"
row(1 as a, 2 as b)
{ 1, 3, 5} 
e1 union all e2
set(e1)

Tratamiento uniforme de subconsultas

Dada la importancia de las tablas, Transact-SQL realiza una interpretación contextual de las subconsultas. Por ejemplo, se considera que una subconsulta en la cláusula from es un conjunto múltiple (tabla). Pero la misma subconsulta utilizada en la cláusula select se considera una subconsulta escalar. De igual forma, se considera que una subconsulta utilizada en el lado izquierdo de un operador in es una subconsulta escalar, mientras se espera que en el lado derecho sea una subconsulta de conjunto múltiple.

Entity SQL elimina estas diferencias. Una expresión tiene una interpretación uniforme que no depende del contexto en el que se utiliza. Entity SQL considera que todas las subconsultas son de conjunto múltiple. Si se desea que la subconsulta tenga un valor escalar, Entity SQL proporciona el operador anyelement que opera en una colección (en este caso, la subconsulta) y extrae el valor singleton de la misma.

Evitar conversiones implícitas en subconsultas

Un efecto secundario relacionado del tratamiento uniforme de las subconsultas es la conversión implícita de las subconsultas en valores escalares. En concreto, en Transact-SQL , un conjunto múltiple de filas (con un campo único) se convierte implícitamente en un valor escalar cuyo tipo de datos es el del campo.

Entity SQL no admite esta conversión implícita. Entity SQL proporciona el operador ANYELEMENT para extraer un valor singleton de una colección y una cláusula select value para evitar crear un contenedor de filas durante una expresión de consulta.

Seleccionar el valor: evitar el contenedor de filas implícitas

La cláusula select de una subconsulta de Transact-SQL crea implícitamente un contenedor de filas en torno a los elementos de la cláusula. Esto implica que no podemos crear colecciones de valores escalares o de objetos. Transact-SQL permite una conversión implícita entre un tipo de fila con un campo y un valor singleton del mismo tipo de datos.

Entity SQL proporciona la cláusula select value para omitir la creación de filas implícitas. Solo se puede especificar un elemento en una cláusula select value. Cuando se utiliza este tipo de cláusula, no se crea ningún contenedor de filas en torno a los elementos de la cláusula select y se puede generar una colección de la forma deseada, por ejemplo: select value a.

Entity SQL también proporciona el constructor de filas para crear filas arbitrarias. La cláusula select toma uno o más elementos en la proyección y devuelve un registro de datos con campos, de la siguiente forma:

select a, b, c

Correlación izquierda y uso de alias

En Transact-SQL , las expresiones de un ámbito determinado (una cláusula única como select o from) no pueden hacer referencia a expresiones definidas anteriormente en el mismo ámbito. Algunos dialectos de SQL (incluido Transact-SQL ) admiten formas limitadas de estas en la cláusula from.

Entity SQL generaliza las correlaciones izquierdas de la cláusula from y las trata uniformemente. Las expresiones de la cláusula from pueden hacer referencia a definiciones anteriores (a la izquierda) en la misma cláusula sin necesidad de una sintaxis adicional.

Entity SQL también impone restricciones adicionales en consultas que afectan a cláusulas group by. Las expresiones de las cláusulas select y having de dichas consultas solo pueden hacer referencia a las claves group by a través de sus alias. La construcción siguiente es válida en Transact-SQL pero no lo es en Entity SQL :

select t.x + t.y from T as t group by t.x + t.y

Para hacer esto en Entity SQL :

select k from T as t group by (t.x + t.y) as k

Hacer referencia a columnas (propiedades) de tablas (colecciones)

Todas las referencias de columna de Entity SQL se deben calificar con el alias de la tabla. La construcción siguiente (suponiendo que a es una columna válida de la tabla T) es válida en Transact-SQL pero no lo es en Entity SQL .

select a from T

El formato de Entity SQL es:

select t.a as A from T as t

Los alias de tabla son opcionales en la cláusula from. El nombre de la tabla se utiliza como alias implícito. Entity SQL también permite el formato siguiente:

select Tab.a from Tab

Transact-SQL usa la notación "." para hacer referencia a las columnas de (una fila de) una tabla. Entity SQL amplía esta notación (que toma prestada de los lenguajes de programación) para admitir la navegación a través de las propiedades de un objeto.

Por ejemplo, si p es una expresión de tipo Persona, lo siguiente es la sintaxis de Entity SQL para hacer referencia a la ciudad de la dirección de esta persona.

p.Address.City

No hay compatibilidad con *

Transact-SQL admite la sintaxis * sin calificar como alias de la fila completa y la sintaxis * calificada (t.*) como acceso directo para los campos de esa tabla. Además, Transact-SQL contempla un agregado count(*) especial, que incluye valores NULL.

Entity SQL no admite la construcción *. Las consultas Transact-SQL con el formato select * from T y select T1.* from T1, T2... se pueden expresar en Entity SQL como select value t from T as t y select value t1 from T1 as t1, T2 as t2..., respectivamente. Además, estas construcciones administran la herencia (capacidad de sustitución de valores), mientras que las variantes de select * se restringen a las propiedades de nivel superior del tipo declarado.

Entity SQL no admite el agregado count(*). En su lugar, utilice count(0).

Cambios de Group By

Entity SQL admite el uso de alias de las claves group by. Las expresiones de la cláusula select y de la cláusula having deben hacer referencia a las claves group by a través de estos alias. Por ejemplo, considere esta sintaxis de Entity SQL :

select k1, count(t.a), sum(t.a)
from T as t
group by t.b + t.c as k1

...es equivalente al código siguiente de Transact-SQL :

select b + c, count(*), sum(a) 
from T
group by b + c

Agregados basados en colecciones

Entity SQL admite dos tipos de agregados.

Los agregados basados en colecciones operan en colecciones y generan el resultado agregado. Estos pueden aparecer en cualquier parte de la consulta y no requieren una cláusula group by. Por ejemplo:

select t.a as a, count({1,2,3}) as b from T as t

Entity SQL también admite agregados del estilo de SQL. Por ejemplo:

select a, sum(t.b) from T as t group by t.a as a

Uso de la cláusula ORDER BY

Transact-SQL permite especificar cláusulas ORDER BY solo en el bloque SELECT .. FROM .. WHERE de nivel superior. En Entity SQL , puede utilizar una expresión ORDER BY anidada que se puede colocar en cualquier parte de la consulta, pero la ordenación en una consulta anidada no se conserva.

-- The following query will order the results by the last name
SELECT C1.FirstName, C1.LastName
        FROM AdventureWorks.Contact as C1
        ORDER BY C1.LastName

-- In the following query ordering of the nested query is ignored.  SELECT C2.FirstName, C2.LastName
    FROM (SELECT C1.FirstName, C1.LastName
        FROM AdventureWorks.Contact as C1
        ORDER BY C1.LastName) as C2

Identificadores

En Transact-SQL , la comparación del identificador está basada en la intercalación de la base de datos actual. En Entity SQL , los identificadores son siempre sin distinción entre mayúsculas y minúsculas, pero tienen en cuenta los acentos (es decir, Entity SQL distingue entre caracteres con y sin acento; por ejemplo, 'e' no es igual a 'é'). Entity SQL trata las versiones de las letras que parecen iguales pero proceden de páginas de códigos diferentes como caracteres distintos. Para obtener más información, vea Juego de caracteres de entrada (Entity SQL).

Funcionalidad de Transact-SQL no disponible en Entity SQL

La funcionalidad de Transact-SQL siguiente no está disponible en Entity SQL .

  • DML
    Entity SQL no proporciona actualmente compatibilidad con las instrucciones DML (inserción, actualización, eliminación).
  • DDL
    Entity SQL no proporciona compatibilidad con DDL en la versión actual.
  • Programación imperativa
    Entity SQL no proporciona compatibilidad con la programación imperativa, a diferencia de Transact-SQL . Utilice un lenguaje de programación en su lugar.
  • Funciones de agrupamiento
    Entity SQL no proporciona aún compatibilidad con las funciones de agrupamiento (por ejemplo, CUBE, ROLLUP y GROUPING_SET).
  • Funciones analíticas
    Entity SQL no proporciona aún compatibilidad con las funciones analíticas.
  • Funciones y operadores integrados
    Entity SQL admite un subconjunto de funciones y operadores integrados de Transact-SQL . Es probable que estos operadores y funciones sean admitidos por los principales proveedores de almacenamiento. Entity SQL utiliza las funciones específicas del almacén declaradas en un manifiesto del proveedor. Además, Entity Framework permite declarar funciones de almacenamiento existentes integradas y definidas por el usuario, para usarlas en Entity SQL .
  • Sugerencias
    Entity SQL no proporciona mecanismos para sugerencias de consulta.
  • Resultados de un consulta por lotes
    Entity SQL no admite resultados de una consulta por lotes. Por ejemplo, el siguiente Transact-SQL es válido (enviar como un lote):
select * from products;
select * from catagories;

Vea también

Conceptos

Información general de Entity SQL
Expresiones no admitidas (Entity SQL)