Condividi tramite

Differenze tra Entity SQL e Transact-SQL

  • Articolo

In questo argomento vengono descritte le differenze tra Entity SQL e Transact-SQL.

Supporto di ereditarietà e relazioni

In Entity SQL vengono utilizzati direttamente gli schemi di entità concettuali e sono supportate le funzionalità EDM come l'ereditarietà e le relazioni.

Quando si utilizza l'ereditarietà, è spesso utile selezionare le istanze di un sottotipo da un insieme di istanze di supertipi. Questa operazione è possibile grazie all'operatore oftype in Entity SQL (simile a oftype nelle sequenze C#). Per informazioni su questo e altri operatori di tipo, vedere Operatori di tipo (Entity SQL).

Supporto per gli insiemi

In Entity SQL gli insiemi vengono trattati come entità di prima classe. Ad esempio:

  • Le espressioni sugli insiemi sono valide in una clausola from.

  • Le sottoquery in e exists sono state generalizzate per consentire qualsiasi insieme.

    Una sottoquery è un tipo di insieme. e1 in e2 e exists(e) sono i costrutti Entity SQL per l'esecuzione di queste operazioni.

  • Le operazioni Set, ad esempio union, intersect ed except, possono ora essere utilizzate sugli insiemi.

  • I join funzionano sugli insiemi.

Supporto per le espressioni

In Transact-SQL sono presenti sottoquery (tabelle) ed espressioni (righe e colonne).

Per supportare gli insiemi e gli insiemi nidificati, Entity SQL trasforma tutti gli elementi in espressione. A differenza di SQL, Entity SQL è componibile e ogni espressione può essere utilizzata in qualunque posizione. Le espressioni di query hanno sempre come risultato insiemi dei tipi previsti e possono essere utilizzate in qualunque posizione in cui è consentita un'espressione sugli insiemi. Per informazioni sulle espressioni Transact-SQL non supportate in Entity SQL, vedere Espressioni non supportate (Entity SQL).

Le query seguenti sono tutte query Entity SQL valide:

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

Modalità di gestione uniforme delle sottoquery

Vista l'enfasi posta sulle tabelle, in Transact-SQL viene eseguita l'interpretazione contestuale delle sottoquery. Una sottoquery nella clausola from viene ad esempio considerata come un multiset (tabella). La stessa sottoquery utilizzata nella clausola select viene invece considerata come una sottoquery scalare. Analogamente, una sottoquery utilizzata sul lato sinistro di un operatore in viene considerata come una sottoquery scalare, mentre sul lato destro è prevista una sottoquery multiset.

In Entity SQL vengono eliminate queste differenze. Un'espressione ha un'interpretazione uniforme che non dipende dal contesto in cui viene utilizzata. In Entity SQL tutte le sottoquery vengono considerate sottoquery multiset. Se dalla sottoquery si desidera ottenere un valore scalare, Entity SQL fornisce l'operatore anyelement che opera su un insieme, in questo caso, la sottoquery, ed estrae un valore singleton dall'insieme.

Eliminazione della presenza di coercizioni implicite per le sottoquery

Un effetto collaterale della modalità di gestione uniforme delle sottoquery è la conversione implicita delle sottoquery in valori scalari. In particolare, in Transact-SQL un multiset di righe (con un singolo campo) viene convertito in modo implicito in un valore scalare il cui tipo di dati è quello del campo.

Entity SQL non supporta questa coercizione implicita. Entity SQL fornisce l'operatore ANYELEMENT per l'estrazione di un valore singleton da un insieme e una clausola select value che consente di evitare di creare un wrapper di riga durante un'espressione di query.

SELECT VALUE: eliminazione della presenza del wrapper di riga implicito

Transact-SQL è ambiguo per quanto riguarda la modalità di gestione del risultato di una query. Tramite la clausola SELECT in una sottoquery Transact-SQL viene creato in modo implicito un wrapper di riga intorno agli elementi della clausola. Per questo motivo, non è possibile creare insiemi di valori scalari o di oggetti. Transact-SQL consente una coercizione implicita tra un tipo di riga con un campo e un valore singleton dello stesso tipo di dati.

Entity SQL fornisce la clausola select value per ignorare la costruzione di riga implicita. Nella clausola select value è possibile specificare un solo elemento. Quando viene utilizzata questa clausola, non viene costruito alcun wrapper di riga intorno agli elementi nella clausola select e può essere prodotto un insieme della forma desiderata, ad esempio select value a.

Entity SQL fornisce anche il costruttore riga per costruire righe arbitrarie. select accetta uno o più elementi nella proiezione e restituisce un record di dati con i campi, nel modo seguente:

select a, b, c

Correlazione sinistra e utilizzo di alias

In Transact-SQL le espressioni in un determinato ambito (una singola clausola come select o from) non possono fare riferimento alle espressioni definite in precedenza nello stesso ambito. Alcuni dialetti di SQL (incluso Transact-SQL) supportano forme limitate di questi comportamenti nella clausola from.

In Entity SQL le correlazioni sinistre nella clausola from vengono generalizzate e trattate in modo uniforme. Le espressioni nella clausola from possono fare riferimento a definizioni precedenti (definizioni a sinistra) nella stessa clausola senza che sia necessaria sintassi aggiuntiva.

In Entity SQL vengono inoltre imposte restrizioni aggiuntive sulle query che implicano l'utilizzo di clausole group by. Le espressioni nella clausola select e nella clausola having di tali query possono fare riferimento alle chiavi group by solo tramite i relativi alias. Il costrutto seguente è valido in Transact-SQL ma non in Entity SQL:

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

Per eseguire questa operazione in Entity SQL:

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

Riferimento a colonne (proprietà) di tabelle (insiemi)

Tutti i riferimenti alle colonne in Entity SQL devono essere qualificati con l'alias di tabella. Il costrutto seguente (presupponendo che a sia una colonna valida della tabella T) è valido in Transact-SQL ma non in Entity SQL.

select a from T

Il formato in Entity SQL è:

select t.a as A from T as t

Gli alias di tabella sono facoltativi nella clausola from. Il nome della tabella viene utilizzato come alias implicito. In Entity SQL è consentito anche il formato seguente:

select Tab.a from Tab

Navigazione negli oggetti

In Transact-SQL viene utilizzata la notazione "." per fare riferimento alle colonne di (una riga di) una tabella. In Entity SQL questa notazione (presa in prestito dai linguaggi di programmazione) viene estesa per supportare la navigazione attraverso le proprietà di un oggetto.

Se, ad esempio, p è un'espressione del tipo Person, di seguito è riportata la sintassi Entity SQL che consente di fare riferimento alla città dell'indirizzo di tale persona.

p.Address.City

Mancanza di supporto per *

Transact-SQL supporta la sintassi * non qualificata come alias per l'intera riga e la sintassi * qualificata (t. *) come collegamento per i campi della tabella. In Transact-SQL è inoltre consentita un'aggregazione count(*) speciale che include i valori null.

Entity SQL non supporta il costrutto *. Le query Transact-SQL nel formato select * from T e select T1.* from T1, T2... possono essere espresse in Entity SQL come select value t from T as t e select value t1 from T1 as t1, T2 as t2..., rispettivamente. Questi costrutti consentono inoltre di gestire l'ereditarietà (sostituibilità del valore), mentre le varianti select * sono limitate alle proprietà di primo livello del tipo dichiarato.

Entity SQL non supporta l'aggregato count(*). Al suo posto, è possibile utilizzare count(0).

Modifiche a Group By

Entity SQL supporta l'utilizzo di alias delle chiavi group by. Le espressioni nella clausola select e nella clausola having devono fare riferimento alle chiavi group by attraverso questi alias. La sintassi Entity SQL seguente:

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

...è ad esempio equivalente alla sintassi Transact-SQL seguente:

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

Aggregazioni basate sugli insiemi

Entity SQL supporta due tipi di aggregazioni.

Le aggregazioni basate sugli insiemi operano sugli insiemi e producono il risultato aggregato. Possono essere presenti in un punto qualsiasi nella query e non richiedono una clausola group by. Ad esempio:

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

Entity SQL supporta inoltre le aggregazioni di tipo SQL. Ad esempio:

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

Utilizzo della clausola ORDER BY

Transact-SQL consente di specificare le clausole ORDER BY solo nel blocco SELECT ... FROM .. WHERE di livello superiore. In Entity SQL è possibile utilizzare un'espressione ORDER BY nidificata che può essere posizionata in un punto qualsiasi nella query, ma l'ordinamento in una query nidificata non viene mantenuto.

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

Identificatori

In Transact-SQL il confronto tra identificatori si basa sulle regole di confronto del database corrente. Negli identificatori di Entity SQL non viene mai operata la distinzione tra maiuscole e minuscole, mentre viene operata la distinzione tra caratteri accentati e non accentati. (ad esempio, 'e' non è uguale a 'è'). Entity SQL considera come caratteri diversi le versioni delle lettere che appaiono uguali ma presentano una tabella codici diversa. Per ulteriori informazioni, vedere Set di caratteri di input (Entity SQL).

Funzionalità Transact-SQL non disponibili in Entity SQL

Le funzionalità Transact-SQL seguenti non sono disponibili in Entity SQL.

  • DML
    Entity SQL non fornisce attualmente supporto per le istruzioni DML (INSERT, UPDATE, DELETE).
  • DDL
    Entity SQL non fornisce supporto per DDL nella versione corrente.
  • Programmazione imperativa
    Entity SQL non fornisce supporto per la programmazione imperativa, a differenza di Transact-SQL. Utilizzare invece un linguaggio di programmazione.
  • Funzioni di raggruppamento
    Entity SQL non fornisce ancora supporto per le funzioni di raggruppamento (ad esempio CUBE, ROLLUP e GROUPING_SET).
  • Funzioni analitiche
    Entity SQL non fornisce (ancora) supporto per le funzioni analitiche.
  • Funzioni e operatori predefiniti
    Entity SQL supporta un sottoinsieme delle funzioni e degli operatori Transact-SQL predefiniti. È probabile che queste funzioni e questi operatori siano supportati dai principali provider dell'archivio. In Entity SQL vengono utilizzate le funzioni specifiche dell'archivio dichiarate in un manifesto del provider. Entity Data Model consente inoltre di dichiarare funzioni di archivio esistenti definite dall'utente e predefinite che possono essere utilizzate da Entity SQL.
  • Hint
    Entity SQL non fornisce meccanismi per gli hint per le query.

Vedere anche

Concetti

Panoramica su Entity SQL
Espressioni non supportate (Entity SQL)