Hoe Entity SQL verschilt van Transact-SQL

In dit artikel worden de verschillen tussen Entity SQL en Transact-SQL beschreven.

Ondersteuning voor overname en relaties

Entity SQL werkt rechtstreeks met conceptuele entiteitsschema's en ondersteunt conceptuele modelfuncties zoals overname en relaties.

Wanneer u met overname werkt, is het vaak handig om exemplaren van een subtype te selecteren uit een verzameling supertype-exemplaren. De operator oftype in Entity SQL (vergelijkbaar met oftype in C#-reeksen) biedt deze mogelijkheid.

Ondersteuning voor verzamelingen

Entity SQL behandelt verzamelingen als eersteklas entiteiten. Voorbeeld:

• Verzamelingsexpressies zijn geldig in een from component.

• in en exists subquery's zijn gegeneraliseerd om verzamelingen toe te staan.

  Een subquery is een soort verzameling. e1 in e2 en exists(e) zijn de Entity SQL-constructies om deze bewerkingen uit te voeren.

• Bewerkingen instellen, zoals union, intersecten except, worden nu uitgevoerd op verzamelingen.

• Joins werken op verzamelingen.

Ondersteuning voor expressies

Transact-SQL heeft subquery's (tabellen) en expressies (rijen en kolommen).

Om verzamelingen en geneste verzamelingen te ondersteunen, maakt Entity SQL alles een expressie. Entiteit SQL kan beter worden composeerbaar dan Transact-SQL. Elke expressie kan overal worden gebruikt. Query-expressies resulteren altijd in verzamelingen van de verwachte typen en kunnen overal worden gebruikt waar een verzamelingsexpressie is toegestaan. Zie Niet-ondersteunde expressies voor meer informatie over Transact-SQL-expressies die niet worden ondersteund in Entity SQL.

Hier volgen alle geldige entiteits-SQL-query's:

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

Uniforme behandeling van subquery's

Gezien de nadruk op tabellen, voert Transact-SQL contextuele interpretatie van subquery's uit. Een subquery in de from component wordt bijvoorbeeld beschouwd als een multiset (tabel). Maar dezelfde subquery die in de select component wordt gebruikt, wordt beschouwd als een scalaire subquery. Op dezelfde manier wordt een subquery die aan de linkerkant van een in operator wordt gebruikt, beschouwd als een scalaire subquery, terwijl de rechterkant naar verwachting een subquery met meerdere verzamelingen is.

Entiteit SQL elimineert deze verschillen. Een expressie heeft een uniforme interpretatie die niet afhankelijk is van de context waarin deze wordt gebruikt. Entiteit SQL beschouwt alle subquery's als subquery's met meerdere subsets. Als een scalaire waarde uit de subquery is gewenst, biedt Entity SQL de anyelement operator die werkt voor een verzameling (in dit geval de subquery) en haalt een singleton-waarde uit de verzameling op.

Impliciete coercions voor subquery's vermijden

Een gerelateerd neveneffect van uniforme behandeling van subquery's is impliciete conversie van subquery's naar scalaire waarden. In Transact-SQL wordt een multiset rijen (met één veld) impliciet geconverteerd naar een scalaire waarde waarvan het gegevenstype dat van het veld is.

Entiteit SQL biedt geen ondersteuning voor deze impliciete dwang. Entity SQL biedt de operator voor het ANYELEMENT extraheren van een singleton-waarde uit een verzameling en een select value component om te voorkomen dat er een rij-wrapper wordt gemaakt tijdens een query-expressie.

Waarde selecteren: de impliciete rijwikkelaar vermijden

De select-component in een Transact-SQL-subquery maakt impliciet een rijwikkelaar rond de items in de component. Dit impliceert dat we geen verzamelingen scalaire of objecten kunnen maken. Met Transact-SQL kan een impliciete dwang tussen een met één rowtype veld en een singletonwaarde van hetzelfde gegevenstype worden gebruikt.

Entity SQL biedt de select value component om de impliciete rijconstructie over te slaan. Er kan slechts één item worden opgegeven in een select value component. Wanneer een dergelijke component wordt gebruikt, wordt er geen rijwikkelaar gemaakt rond de items in de select component en kan er bijvoorbeeld select value aeen verzameling van de gewenste shape worden geproduceerd.

Entiteit SQL biedt ook de rijconstructor voor het maken van willekeurige rijen. select neemt een of meer elementen in de projectie en resulteert in een gegevensrecord met velden:

select a, b, c

Linkercorrelatie en aliasing

In Transact-SQL kunnen expressies in een bepaald bereik (één component zoals select of from) niet verwijzen naar expressies die eerder in hetzelfde bereik zijn gedefinieerd. Sommige dialecten van SQL (inclusief Transact-SQL) ondersteunen beperkte vormen van deze in de from component.

Entiteit SQL generaliseert linkse correlaties in de from component en behandelt ze uniform. Expressies in de from component kunnen verwijzen naar eerdere definities (definities aan de linkerkant) in dezelfde component zonder dat er extra syntaxis nodig is.

Entiteit SQL legt ook aanvullende beperkingen op voor query's die betrekking hebben op group by componenten. Expressies in de select component en having component van dergelijke query's kunnen alleen verwijzen naar de group by sleutels via hun aliassen. De volgende constructie is geldig in Transact-SQL, maar bevindt zich niet in Entity SQL:

SELECT t.x + t.y FROM T AS t group BY t.x + t.y

Ga als volgt te werk in Entity SQL:

SELECT k FROM T AS t GROUP BY (t.x + t.y) AS k

Verwijzen naar kolommen (eigenschappen) van tabellen (verzamelingen)

Alle kolomverwijzingen in Entity SQL moeten worden gekwalificeerd met de tabelalias. De volgende constructie (ervan uitgaande dat het a een geldige kolom van de tabel Tis) is geldig in Transact-SQL, maar niet in Entity SQL.

SELECT a FROM T

Het formulier Entiteits-SQL is

SELECT t.a AS A FROM T AS t

De tabelaliassen zijn optioneel in de from component. De naam van de tabel wordt gebruikt als de impliciete alias. Entiteit SQL staat ook het volgende formulier toe:

SELECT Tab.a FROM Tab

Navigatie door objecten

Transact-SQL maakt gebruik van de notatie '.' voor het verwijzen naar kolommen van (een rij van) een tabel. Entity SQL breidt deze notatie uit (geleend uit programmeertalen) ter ondersteuning van navigatie door eigenschappen van een object.

Als dit bijvoorbeeld p een expressie van het type Persoon is, is het volgende de entiteits-SQL-syntaxis voor het verwijzen naar de plaats van het adres van deze persoon.

p.Address.City

Geen ondersteuning voor *

Transact-SQL ondersteunt de niet-gekwalificeerde * syntaxis als alias voor de hele rij en de gekwalificeerde * syntaxis (t.*) als snelkoppeling voor de velden van die tabel. Bovendien maakt Transact-SQL een aggregaties met speciale aantallen(*) mogelijk, die null-waarden bevat.

Entiteit SQL biedt geen ondersteuning voor de *-constructie. Transact-SQL-query's van het formulier select * from T en select T1.* from T1, T2... kunnen worden uitgedrukt in entiteits-SQL als select value t from T as t en select value t1 from T1 as t1, T2 as t2..., respectievelijk. Bovendien verwerken deze constructies overname (waardevervanging), terwijl de select * varianten worden beperkt tot eigenschappen op het hoogste niveau van het gedeclareerde type.

Entiteit SQL biedt geen ondersteuning voor de count(*) statistische functie. Gebruik in plaats daarvan count(0).

Wijzigingen in Groeperen op

Entity SQL ondersteunt aliasing van group by sleutels. Expressies in de select component en having component moeten verwijzen naar de group by sleutels via deze aliassen. Bijvoorbeeld deze entiteitssyntaxis van SQL:

SELECT k1, count(t.a), sum(t.a)
FROM T AS t
GROUP BY t.b + t.c AS k1

... is gelijk aan de volgende Transact-SQL:

SELECT b + c, count(*), sum(a)
FROM T
GROUP BY b + c

Aggregaties op basis van verzamelingen

Entity SQL ondersteunt twee soorten aggregaties.

Op verzamelingen gebaseerde aggregaties werken op verzamelingen en produceren het geaggregeerde resultaat. Deze kunnen overal in de query worden weergegeven en er is geen component vereist group by . Voorbeeld:

SELECT t.a AS a, count({1,2,3}) AS b FROM T AS t

Entiteit SQL biedt ook ondersteuning voor statistische functies in SQL-stijl. Voorbeeld:

SELECT a, sum(t.b) FROM T AS t GROUP BY t.a AS a

ORDER BY-componentgebruik

Met Transact-SQL kunnen ORDER BY componenten alleen worden opgegeven in het bovenste SELECT .. FROM .. WHERE blok. In Entity SQL kunt u een geneste ORDER BY expressie gebruiken en deze overal in de query plaatsen, maar de volgorde in een geneste query blijft niet behouden.

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

Identifiers

In Transact-SQL is de vergelijking van id's gebaseerd op de sortering van de huidige database. In Entity SQL zijn id's altijd niet hoofdlettergevoelig en accentgevoelig (entiteits-SQL maakt onderscheid tussen accent- en niet-begeleide tekens; bijvoorbeeld 'a' is niet gelijk aan 'ấ'). Entity SQL behandelt versies van letters die hetzelfde lijken, maar afkomstig zijn van verschillende codepagina's als verschillende tekens. Zie Invoertekenset voor meer informatie.

Transact-SQL-functionaliteit niet beschikbaar in Entiteit SQL

De volgende Transact-SQL-functionaliteit is niet beschikbaar in Entity SQL.

DML
Entiteit SQL biedt momenteel geen ondersteuning voor DML-instructies (invoegen, bijwerken, verwijderen).

DDL
Entity SQL biedt geen ondersteuning voor DDL in de huidige versie.

Imperatieve programmering
Entity SQL biedt geen ondersteuning voor imperatieve programmering, in tegenstelling tot Transact-SQL. Gebruik in plaats daarvan een programmeertaal.

Groeperingsfuncties
Entiteit SQL biedt nog geen ondersteuning voor groeperingsfuncties (bijvoorbeeld KUBUS, ROLLUP en GROUPING_SET).

Analytische functies
Entiteit SQL biedt (nog) geen ondersteuning voor analysefuncties.

Ingebouwde functies, operators
Entity SQL ondersteunt een subset van de ingebouwde functies en operators van Transact-SQL. Deze operators en functies worden waarschijnlijk ondersteund door de belangrijkste winkelproviders. Entiteit SQL maakt gebruik van de winkelspecifieke functies die zijn gedeclareerd in een providermanifest. Daarnaast kunt u met Entity Framework ingebouwde en door de gebruiker gedefinieerde bestaande archieffuncties declareren, zodat Entity SQL kan worden gebruikt.

Hints
Entity SQL biedt geen mechanismen voor queryhints.

Queryresultaten batcheren
Entity SQL biedt geen ondersteuning voor batchverwerkingsqueryresultaten. Het volgende is bijvoorbeeld geldig Transact-SQL (verzenden als een batch):

SELECT * FROM products;
SELECT * FROM categories;

De equivalente entiteit SQL wordt echter niet ondersteund:

SELECT value p FROM Products AS p;
SELECT value c FROM Categories AS c;

Entiteit SQL ondersteunt slechts één query-instructie voor het produceren van resultaten per opdracht.

Zie ook

• Overzicht van Entiteit SQL
• Niet-ondersteunde expressies