Ondersteunde SQL-syntaxis

SELECT

De instructie SELECT wordt gebruikt om een query op de database uit te voeren. Het resultaat van een SELECT-instructie is nul of meer rijen met gegevens, waarbij elke rij een vast aantal kolommen heeft. Het aantal kolommen in het resultaat wordt bepaald door de kolomnaam of expressielijst result tussen SELECT en optionele FROM-trefwoorden.

sql-statement   ::=  SELECT [ALL | DISTINCT] result 
                     [FROM table-list] 
                     [WHERE expr] 
                     [GROUP BY expr-list] 
                     [HAVING expr] 
                     [compound-op select-statement]* 
                     [ORDER BY sort-expr-list] 
                     [LIMIT integer [( OFFSET | , ) integer]] 
result          ::=  result-column [, result-column]* 
result-column   ::=  * | table-name . * | expr [[AS] string] 
table-list      ::=  table [ join-op table join-args ]* 
table           ::=  table-name [AS alias] | 
                     ( select ) [AS alias] 
join-op         ::=  , | [NATURAL] [LEFT | RIGHT | FULL] [OUTER | INNER | CROSS] JOIN 
join-args       ::=  [ON expr] [USING ( id-list )] 
compound-op     ::=  UNION | UNION ALL | INTERSECT | EXCEPT 
sort-expr-list  ::=  expr [sort-order] [, expr [sort-order]]* 
sort-order      ::=  [COLLATE collation-name] [ASC | DESC] 
collation-name  ::=  BINARY | NOCASE

Elke expressie kan als een resultaat worden gebruikt. Als een resultaatexpressie bestaat uit *, komen alle kolommen van alle tabellen in de plaats van die ene expressie. Als de expressie bestaat uit de naam van een tabel gevolgd door .*, bestaat het resultaat uit alle kolommen in die ene tabel.

Het trefwoord DISTINCT leidt ertoe dat een subset van resultaatrijen wordt geretourneerd, waarin elke resultaatrij anders is. NULL-waarden worden niet als onderling verschillend behandeld. Het standaardgedrag is dat alle resultaatrijen worden geretourneerd, hetgeen expliciet kan worden gemaakt via het trefwoord ALL.

De query wordt uitgevoerd op een of meer tabellen die worden opgegeven na het trefwoord FROM. Als meerdere tabelnamen worden gescheiden met komma's, gebruikt de query de kruislingse koppeling van de diverse tabellen. De JOIN-syntaxis kan ook worden gebruikt om aan te geven hoe tabellen worden gekoppeld. Het enige type outer join dat wordt ondersteund, is LEFT OUTER JOIN. De componentexpressie ON in join-args moet een booleaanse waarde opleveren. Een subquery tussen haakjes kan als een tabel worden gebruikt in de FROM-component. De gehele FROM-component kan worden weggelaten, waardoor in dit geval het resultaat bestaat uit één enkele rij die bestaat uit de waarden van de expressielijst result.

De component WHERE wordt gebruikt on het aantal rijen dat de query ophaalt te beperken. WHERE-componentexpressies moeten een booleaanse waarde opleveren. Filteren met de component WHERE moet vóór groeperen worden uitgevoerd, opdat WHERE-componentexpressies geen statistische functies omvatten.

De GROUP BY-component leidt ertoe dat een of meer rijen uit het resultaat moeten worden gecombineerd in één rij uitvoer. Een GROUP BY-component is met name handig wanneer het resultaat statistische functies bevat. De expressies in de GROUP BY-component hoeven niet per se voor te komen in de expressielijst SELECT.

De component HAVING lijkt in die zin op WHERE, dat deze het door de instructie geretourneerde aantal rijen beperkt. De component HAVING wordt echter toegepast nadat de groepering die wordt opgegeven door een GROUP BY-component heeft plaatsgevonden. Daarom kan de HAVING-expressie verwijzen naar waarden met daarin statistische functies. Een HAVING-componentexpressie hoeft niet per se voor te komen in de lijst SELECT. Evenals bij een WHERE-expressie, moet de HAVING-expressie een booleaanse waarde opleveren.

Door de ORDER BY-component worden de rijen van de uitvoer gesorteerd. Het argument sort-expr-list bij de ORDER BY-component bestaat uit een lijst met expressies die als de sleutel voor de sorteerbewerking worden gebruikt. De expressies hoeven geen onderdeel te zijn van het resultaat van een enkelvoudige SELECT, maar bij een samengestelde SELECT (een SELECT die een van de operatoren compound-op gebruikt) moet elke sorteerexpressie exact overeenkomen met een van de resultaatkolommen. Elke sorteerexpressie kan optioneel worden gevolgd door een sort-order-component die bestaat uit het trefwoord COLLATE en de naam van een sorteerfunctie die wordt gebruikt voor het rangschikken van tekst, en/of het trefwoord ASC of DESC om de sorteervolgorde (oplopend of aflopend) aan te geven. De sort-order kan worden weggelaten, zodat de standaardinstelling (oplopende volgorde) wordt gebruikt. Zie COLLATE voor een definitie van de component COLLATE en de sorteerfuncties.

De component LIMIT definieert een bovengrens voor het aantal rijen dat wordt geretourneerd in het resultaat. Een negatieve LIMIT geeft aan dat er geen bovengrens is. De optionele OFFSET volgend op LIMIT geeft aan hoeveel rijen moeten worden overgeslagen aan het begin van de resultatenset. Bij een samengestelde SELECT-query mag de LIMIT-component alleen voorkomen na de laatste SELECT-instructie, waarbij de limiet geldt voor de gehele query. Denk eraan dat als het trefwoord OFFSET wordt gebruikt in de LIMIT-component, de limiet het eerste gehele getal is en dat de verschuiving (offset) het tweede gehele getal is. Als in plaats van het trefwoord OFFSET een komma wordt gebruikt, is de verschuiving het eerste getal en is de limiet het tweede getal. Deze schijnbare contradictie is doelbewust: hierdoor wordt een maximale compatibiliteit met verouderde SQL-databasesystemen verkregen.

Een samengestelde SELECT wordt gevormd door twee of meer enkelvoudige SELECT-instructies die zijn verbonden door een van de operatoren UNION, UNION ALL, INTERSECT of EXCEPT. In een samengestelde SELECT moeten alle deel uitmakende SELECT-instructies hetzelfde aantal resultaatkolommen opgeven. Er kan slechts een enkelvoudige ORDER BY-component voorkomen na de laatste SELECT-instructie (en vóór de enkelvoudige LIMIT-component als er één is opgegeven). De operatoren UNION en UNION ALL combineren de resultaten van de voorafgaande en de volgende SELECT-instructies in één tabel. Het verschil is dat bij UNION alle resultaatrijen van elkaar verschillen, terwijl er bij UNION ALL duplicaatrijen kunnen voorkomen. De operator INTERSECT neemt het snijpunt van de resultaten van de voorafgaande en volgende SELECT-instructies. EXCEPT neemt het resultaat van de voorafgaande SELECT nadat eerst de resultaten van de volgende SELECT zijn verwijderd. Wanneer er drie of meer SELECT-instructies worden verbonden in een samenstelling, is de volgorde van groepering eerste naar laatste.

Zie Expressies voor een definitie van toegestane expressies.

Vanaf versie AIR 2.5 wordt de SQL CAST-operator ondersteund voor het lezen van BLOB-gegevens die moeten worden omgezet in ActionScript ByteArray-objecten. De volgende code leest bijvoorbeeld onbewerkte gegevens die niet zijn opgeslagen in de AMF-indeling en slaat deze op in een ByteArray-object:

stmt.text = "SELECT CAST(data AS ByteArray) AS data FROM pictures;"; 
stmt.execute(); 
var result:SQLResult = stmt.getResult(); 
var bytes:ByteArray = result.data[0].data;

INSERT

sql-statement  ::=  INSERT [OR conflict-algorithm] INTO [database-name.] table-name [(column-list)] VALUES (value-list) | 
                    INSERT [OR conflict-algorithm] INTO [database-name.] table-name [(column-list)] select-statement 
                    REPLACE INTO [database-name.] table-name [(column-list)] VALUES (value-list) | 
                    REPLACE INTO [database-name.] table-name [(column-list)] select-statement

De eerste vorm (met het trefwoord VALUES) maakt één nieuwe rij in een bestaande tabel. Als er geen column-list wordt opgegeven, moet het aantal waarden gelijk zijn aan het aantal kolommen in de tabel. Als er wel een column-list wordt opgegeven, moet het aantal waarden overeenkomen met het aantal opgegeven kolommen. Kolommen van de tabel die niet voorkomen in de kolommenlijst, worden gevuld met de standaardwaarde die is opgegeven bij het maken van de tabel, of met NULL als er geen standaardwaarde is gedefinieerd.

De tweede vorm van de INSERT-instructie maakt gebruik van gegevens uit een SELECT-instructie. Het aantal kolommen in het resultaat van de SELECT moet exact overeenkomen met het aantal kolommen in de tabel als column-list niet is opgegeven, of moet overeenkomen met het aantal kolommen dat wordt genoemd in de column-list. Er wordt een nieuw item in de tabel gemaakt voor elke rij van het SELECT-resultaat. De SELECT kan enkelvoudig of samengesteld zijn. Zie SELECT voor een definitie van toegestane SELECT-instructies.

Met de optionele conflict-algorithm kan een alternatief algoritme voor het oplossen van beperkingsconflicten worden opgegeven, dat tijdens het gebruik van deze ene instructie moet worden gebruikt. Zie Speciale instructies en componenten voor een uitleg en definitie van conflictalgoritmen.

De twee vormen van REPLACE INTO van de instructie zijn gelijk aan het gebruik van de standaardvorm van INSERT [OR conflict-algorithm] met het conflictalgoritme REPLACE (d.w.z. de vorm INSERT OR REPLACE...).

De twee vormen van REPLACE INTO van de instructie zijn gelijk aan het gebruik van de standaardvorm van INSERT [OR conflict-algorithm] met het conflictalgoritme REPLACE (d.w.z. de vorm INSERT OR REPLACE...).

UPDATE

De update-opdracht wijzigt de bestaande records in een tabel.

sql-statement  ::=  UPDATE [database-name.] table-name SET column1=value1, column2=value2,... [WHERE expr]

De opdracht bestaat uit het trefwoord UPDATE gevolgd door de naam van de tabel waarin u de records wilt bijwerken. Na het trefwoord SET geeft u in een lijst met komma's als scheidingsteken de naam van de kolom op en de waarde waarin de kolom moet worden gewijzigd. De WHERE-componentexpressie verschaft de rij of rijen waarin de records worden bijgewerkt.

DELETE

sql-statement  ::=  DELETE FROM [database-name.] table-name [WHERE expr]

De instructie bestaat uit de DELETE FROM-trefwoorden gevolgd door de naam van de tabel waaruit records moeten worden verwijderd.

Zonder een WHERE-component worden alle rijen van de tabel verwijderd. Als een WHERE-component wordt opgegeven, worden alleen die rijen verwijderd, die overeenkomen met de expressie. De expressie van de WHERE-component moet een booleaanse waarde opleveren. Zie Expressies voor een definitie van toegestane expressies.

CREATE TABLE

sql-statement       ::=  CREATE [TEMP | TEMPORARY] TABLE [IF NOT EXISTS] [database-name.] table-name 
                         ( column-def [, column-def]* [, constraint]* ) 
sql-statement       ::=  CREATE [TEMP | TEMPORARY] TABLE [database-name.] table-name AS select-statement 
column-def          ::=  name [type] [[CONSTRAINT name] column-constraint]* 
type                ::=  typename | typename ( number ) | typename ( number , number ) 
column-constraint   ::=  NOT NULL [ conflict-clause ] | 
                         PRIMARY KEY [sort-order] [ conflict-clause ] [AUTOINCREMENT] | 
                         UNIQUE [conflict-clause] | 
                         CHECK ( expr ) | 
                         DEFAULT default-value | 
                         COLLATE collation-name 
constraint          ::=  PRIMARY KEY ( column-list ) [conflict-clause] | 
                         UNIQUE ( column-list ) [conflict-clause] | 
                         CHECK ( expr ) 
conflict-clause     ::=  ON CONFLICT conflict-algorithm 
conflict-algorithm  ::=  ROLLBACK | ABORT | FAIL | IGNORE | REPLACE 
default-value       ::=  NULL | string | number | CURRENT_TIME | CURRENT_DATE | CURRENT_TIMESTAMP 
sort-order          ::=  ASC | DESC 
collation-name      ::=  BINARY | NOCASE 
column-list         ::=  column-name [, column-name]*

Elke kolomdefinitie is de naam van de kolom gevolgd door het gegevenstype voor die kolom, met daarna een of meer optionele kolombeperkingen. Het gegevenstype voor de kolom bepaalt welke gegevens in die kolom kunnen worden opgeslagen. Als wordt gepoogd om een waarde op te slaan in een kolom met een ander gegevenstype, converteert de runtime de waarde indien mogelijk naar het juiste type. Als dit niet mogelijk is, wordt er een fout gesignaleerd. Zie het gedeelte Ondersteuning van gegevenstypen voor aanvullende informatie.

De kolombeperking NOT NULL geeft aan dat de kolom geen NULL-waarden kan bevatten.

Een UNIQUE-beperking leidt ertoe dat er een index voor de opgegeven kolom of kolommen wordt gemaakt. Deze index moet unieke sleutels bevatten: in geen enkele twee rijen mogen dubbele waarden of combinaties van waarden voor de opgegeven kolom of kolommen voorkomen. Een CREATE TABLE-instructie kan meerdere UNIQUE-beperkingen hebben, waaronder meerdere kolommen met een UNIQUE-beperking in de definitie van de kolom en/of meerdere UNIQUE-beperkingen op tabelniveau.

Een CHECK-beperking definieert een expressie die wordt geëvalueerd en die waar moet zijn voordat de gegevens van de rij kunnen worden ingevoegd of bijgewerkt. De CHECK-expressie moet een booleaanse waarde opleveren.

Een COLLATE-component in een kolomdefinitie geeft aan welke tekstsorteerfunctie moet worden gebruikt bij het vergelijken van tekstitems voor de kolom. Standaard wordt de sorteerfunctie BINARY gebruikt. Zie COLLATE voor meer informatie over de component COLLATE en sorteerfuncties.

De DEFAULT-beperking geeft een standaardwaarde aan die moet worden gebruikt bij het uitvoeren van een INSERT. De waarde kan NULL, een tekenreeksconstante of een getal zijn. De standaardwaarde kan ook een van de speciale, niet-hoofdlettergevoelige trefwoorden CURRENT_TIME, CURRENT_DATE of CURRENT_TIMESTAMP zijn. Als de waarde NULL, een tekenreeksconstante of een getal is, wordt deze letterlijk ingevoegd in de kolom telkens wanneer een INSERT-instructie geen waarde voor de kolom opgeeft. Als de waarde CURRENT_TIME, CURRENT_DATE of CURRENT_TIMESTAMP is, wordt de huidige UTC-datum en/of -tijd ingevoegd in de kolom. Voor CURRENT_TIME is de notatie HH:MM:SS. Voor CURRENT_DATE is de notatie YYYY-MM-DD. De notatie voor CURRENT_TIMESTAMP is YYYY-MM-DD HH:MM:SS.

Door op de normale wijze een PRIMARY KEY op te geven wordt alleen een UNIQUE-index voor de daarmee overeenkomende kolom of kolommen gemaakt. Als de PRIMARY KEY-beperking echter geldt voor een enkelvoudige kolom met daarin gegevens van het type INTEGER (of een van de synoniemen zoals int), wordt die kolom intern gebruikt als de daadwerkelijke primaire sleutel voor de tabel. Dit betekent dat de kolom alleen waarden in de vorm van unieke gehele getallen mag bevatten. (In vele SQLite-implementaties leidt alleen het kolomtype INTEGER ertoe dat de kolom als interne primaire sleutel fungeert, maar in Adobe AIR leiden synoniemen voor INTEGER, zoals int, ook tot dat gedrag.)

Als een tabel geen kolom INTEGER PRIMARY KEY heeft, wordt automatisch een sleutel van gehele getallen gegenereerd wanneer een rij wordt ingevoegd. De primaire sleutel voor een rij is altijd toegankelijk met behulp van een van de speciale namen ROWID, OID of _ROWID_. Deze namen kunnen worden gebruikt ongeacht of het een expliciet gedeclareerde INTEGER PRIMARY KEY of een intern gegenereerde waarde betreft. Als de tabel echter een expliciete INTEGER PRIMARY KEY heeft, wordt de werkelijke kolomnaam (en niet de speciale naam) weergegeven in de resultaatgegevens.

Een kolom INTEGER PRIMARY KEY kan ook het trefwoord AUTOINCREMENT bevatten. Wanneer het trefwoord AUTOINCREMENT wordt gebruikt, genereert de database automatisch een sequentieel incrementele sleutel van gehele getallen en voegt deze automatisch in de kolom INTEGER PRIMARY KEY in wanneer een INSERT-instructie wordt uitgevoerd waarbij geen expliciete kolomwaarde wordt opgegeven.

Er mag slechts één PRIMARY KEY-beperking voorkomen in een CREATE TABLE-instructie. Deze kan onderdeel zijn van een definitie van één kolom of uit één enkelvoudige PRIMARY KEY-beperking op tabelniveau bestaan. Een primaire-sleutelkolom is impliciet NOT NULL.

Met de optionele conflict-clause die kan volgen op vele beperkingen, kan een alternatief algoritme voor het oplossen van beperkingsconflicten voor die beperking worden opgegeven. Standaard is dit ABORT. Verschillende beperkingen binnen dezelfde tabel kunnen verschillende algoritmen voor het oplossen van conflicten hebben. Als een INSERT- of UPDATE-instructie een ander algoritme voor het oplossen van conflicten opgeeft, wordt dat algoritme gebruikt, in plaats van het algoritme dat is opgegeven in de MAKE TABLE-instructie. Zie het gedeelte ON CONFLICT in Speciale instructies en componenten voor meer informatie.

Aanvullende beperkingen, zoals FOREIGN KEY-beperkingen, leiden niet tot een fout, maar worden wel door de runtime genegeerd.

Als het trefwoord TEMP of TEMPORARY voorkomt tussen CREATE en TABLE, is de tabel die wordt gemaakt, alleen zichtbaar binnen dezelfde databaseverbinding (SQLConnection-instantie). Deze wordt automatisch verwijderd wanneer de databaseverbinding wordt gesloten. Alle indices die worden gemaakt voor een tijdelijke tabel, zijn ook tijdelijk. Tijdelijke tabellen en indices worden opgeslagen in een afzonderlijk bestand dat los staat van het hoofddatabasebestand.

Als het optionele prefix (voorvoegsel) database-name wordt opgegeven, wordt de tabel gemaakt in een benoemde database (een database die is verbonden met de SQLConnection-instantie door het aanroepen van de methode attach() met de opgegeven databasenaam). Het is onjuist om zowel een prefix database-name als het trefwoord TEMP op te geven, tenzij het prefix database-name temp is. Als er geen databasenaam wordt opgegeven en als het trefwoord TEMP niet aanwezig is, wordt de tabel gemaakt in de hoofddatabase (de database die was verbonden met de SQLConnection-instantie die de methode open() of openAsync() gebruikt).

Er zijn geen willekeurige limieten voor het aantal kolommen of het aantal beperkingen in een tabel. Ook is er geen willekeurige limiet voor de hoeveelheid gegevens in een rij.

Het formulier CREATE TABLE AS definieert de tabel als de resultatenset van een query. De namen van de tabelkolommen zijn de namen van de kolommen in het resultaat.

Als de optionele component IF NOT EXISTS aanwezig is en er al een andere tabel met dezelfde naam bestaat al, negeert de database de CREATE TABLE-instructie.

Een tabel kan worden verwijderd met de instructie DROP TABLE, terwijl beperkte wijzigingen kunnen worden aangebracht met behulp van de instructie ALTER TABLE.

ALTER TABLE

Met de instructie ALTER TABLE kan de gebruiker de naam van een kolom wijzigen of een nieuwe kolom toevoegen aan een bestaande tabel. Het is niet mogelijk om een kolom te verwijderen uit een tabel.

sql-statement ::= ALTER TABLE [database-name.] table-name alteration 
alteration    ::= RENAME TO new-table-name 
alteration    ::= ADD [COLUMN] column-def

De syntaxis RENAME TO wordt gebruikt om de naam te wijzigen van de tabel die wordt aangeduid met [database-name. ] table-name in new-table-name. Deze instructie kan niet worden gebruikt om een tabel te verplaatsen tussen gekoppelde databases, maar alleen om de naam te wijzigen van een tabel binnen dezelfde database.

Als de tabel waarvan de naam wordt gewijzigd, triggers of indices heeft, blijven deze gekoppeld aan de tabel, ook nadat de naam ervan is gewijzigd. Als er echter weergavedefinities of instructies worden uitgevoerd door triggers die verwijzen naar de tabel waarvan de naam wordt gewijzigd, worden deze niet automatisch gewijzigd met de nieuwe tabelnaam. Als een tabel met een gewijzigde naam gekoppelde weergaven of triggers heeft, moet u de triggers of weergavedefinities handmatig verwijderen en opnieuw maken met de nieuwe tabelnaam.

De syntaxis ADD [COLUMN] wordt gebruikt om een nieuwe kolom toe te voegen aan een bestaande tabel. De nieuwe kolom wordt altijd toegevoegd aan het einde van de lijst met bestaande kolommen. De component column-def kan elk van de in de instructie CREATE TABLE toegestane vormen hebben, maar hierbij gelden de volgende beperkingen:

• De kolom mag geen beperking van het type PRIMARY KEY of UNIQUE hebben.

• De kolom mag geen standaardwaarde voor CURRENT_TIME, CURRENT_DATE of CURRENT_TIMESTAMP hebben.

• Als een beperking van het type NOT NULL is opgegeven, moet de kolom een andere standaardwaarde dan NULL hebben.

De uitvoeringstijd van de instructie ALTER TABLE wordt niet beďnvloed door de hoeveelheid gegevens in de tabel.

DROP TABLE

sql-statement  ::=  DROP TABLE [IF EXISTS] [database-name.] table-name

De instructie DROP TABLE verandert de grootte van het databasebestand niet. Witruimte in de database blijft behouden en wordt gebruikt in volgende INSERT-bewerkingen. Gebruik voor het verwijderen van vrije ruimte in de database de methode SQLConnection.clean(). Als de parameter autoClean wordt ingesteld op true wanneer de database voor de eerste keer wordt gemaakt, wordt de ruimte automatisch vrijgemaakt.

De optionele component IF EXISTS onderdrukt de fout die normaliter zou worden gegeven als de tabel niet bestaat.

CREATE INDEX

De instructie CREATE INDEX bestaat uit de trefwoorden CREATE INDEX, gevolgd door de naam van de nieuwe index, het trefwoord ON, de naam van een eerder gemaakte tabel die moet worden geďndexeerd, en een tussen haakjes geplaatste lijst met namen van kolommen in de tabel, waarvan de waarden worden gebruikt voor de indexsleutel.

sql-statement  ::=  CREATE [UNIQUE] INDEX [IF NOT EXISTS] [database-name.] index-name 
                    ON table-name ( column-name [, column-name]* ) 
column-name    ::=  name [COLLATE collation-name] [ASC | DESC]

Elke kolomnaam kan worden gevolgd door het trefwoord ASC of DESC om de sorteervolgorde aan te geven, maar de sorteervolgordeaanduiding wordt genegeerd door de runtime. Sorteren geschiedt altijd in oplopende volgorde.

De component COLLATE die volgt op elke kolomnaam, definieert een sorteervolgorde die wordt gebruikt voor tekstwaarden in die kolom. De standaardsorteervolgorde is de sorteervolgorde die is gedefinieerd voor die kolom in de instructie CREATE TABLE. Als er geen sorteervolgorde is opgegeven, wordt de sorteervolgorde BINARY gebruikt. Zie COLLATE voor een definitie van de component COLLATE en de sorteerfuncties.

Er zijn geen limieten voor het aantal indices dat aan één tabel kan worden gekoppeld. Ook zijn er geen limieten aan het aantal kolommen in een index.

DROP INDEX

De instructie DROP INDEX verwijdert een index die is toegevoegd met de instructie CREATE INDEX. De opgegeven index wordt volledig verwijderd uit het databasebestand. De enige manier om de index te herstellen is het opnieuw opgeven van de juiste instructie CREATE INDEX.

sql-statement ::= DROP INDEX [IF EXISTS] [database-name.] index-name

De instructie DROP INDEX verandert de grootte van het databasebestand niet. Witruimte in de database blijft behouden en wordt gebruikt in volgende INSERT-bewerkingen. Gebruik voor het verwijderen van vrije ruimte in de database de methode SQLConnection.clean(). Als de parameter autoClean wordt ingesteld op true wanneer de database voor de eerste keer wordt gemaakt, wordt de ruimte automatisch vrijgemaakt.

CREATE VIEW

De instructie CREATE VIEW wijst een naam toe aan een vooraf gedefinieerde instructie SELECT. Deze nieuwe naam kan vervolgens worden gebruikt in een FROM-component van een andere SELECT-instructie in plaats van een tabelnaam. Weergaven worden doorgaans gebruikt voor het vereenvoudigen van query's door het combineren van een samengestelde (en veelgebruikte) set gegevens tot een structuur die kan worden gebruikt in andere bewerkingen.

sql-statement ::= CREATE [TEMP | TEMPORARY] VIEW [IF NOT EXISTS] [database-name.] view-name AS select-statement

Als het trefwoord TEMP of TEMPORARY voorkomt tussen CREATE en VIEW, is de weergave die wordt gemaakt alleen zichtbaar voor de SQLConnection-istantie die de database heeft geopend, en wordt de weergave automatisch verwijderd wanneer de database wordt gesloten.

Als een [database-name] wordt opgegeven, wordt de weergave gemaakt in de benoemde database (een database die was verbonden met de SQLConnection-instantie met de methode attach(), met het opgegeven argument name. Het is onjuist om zowel een [database-name] als het trefwoord TEMP op te geven, tenzij de [database-name] gelijk is aan temp. Als er geen databasenaam wordt opgegeven en als het trefwoord TEMP niet aanwezig is, wordt de weergave gemaakt in de hoofddatabase (de database die was verbonden met de SQLConnection-instantie met de methode open() of openAsync()).

Weergaven zijn alleen-lezen. Een instructie DELETE, INSERT of UPDATE kan alleen worden gebruikt voor een weergave als er ten minste één trigger van het bijbehorende type (INSTEAD OF DELETE, INSTEAD OF INSERT, INSTEAD OF UPDATE) is gedefinieerd. Zie CREATE TRIGGER voor informatie over het maken van een trigger voor een weergave.

Een weergave wordt verwijderd uit een database met de instructie DROP VIEW.

DROP VIEW

De instructie DROP VIEW verwijdert een weergave die is gemaakt met de instructie CREATE VIEW.

sql-statement ::= DROP VIEW [IF EXISTS] view-name

De opgegeven view-name is de naam van de weergave die moet worden uitgenomen. Deze wordt verwijderd uit de database, maar in de onderliggende tabellen worden geen gegevens gewijzigd.

CREATE TRIGGER

De instructie CREATE TRIGGER wordt gebruikt om triggers toe te voegen aan het databaseschema. Een trigger is een databasebewerking (de trigger-action) die automatisch wordt uitgevoerd wanneer een opgegeven databasegebeurtenis (de database-event) plaatsvindt.

sql-statement   ::=  CREATE [TEMP | TEMPORARY] TRIGGER [IF NOT EXISTS] [database-name.] trigger-name 
                     [BEFORE | AFTER] database-event 
                     ON table-name 
                     trigger-action 
sql-statement   ::=  CREATE [TEMP | TEMPORARY] TRIGGER [IF NOT EXISTS] [database-name.] trigger-name 
                     INSTEAD OF database-event 
                     ON view-name 
                     trigger-action 
database-event  ::=  DELETE | 
                     INSERT | 
                     UPDATE | 
                     UPDATE OF column-list 
trigger-action  ::=  [FOR EACH ROW] [WHEN expr] 
                     BEGIN 
                       trigger-step ; 
                       [ trigger-step ; ]* 
                     END 
trigger-step    ::=  update-statement | 
                     insert-statement | 
                     delete-statement | 
                     select-statement 
column-list     ::=  column-name [, column-name]*

Een trigger moet in werking treden wanneer een DELETE, INSERT of UPDATE van een bepaalde databasetabel plaatsvindt, of telkens wanneer een UPDATE van een of meer opgegeven kolommen van een tabel worden bijgewerkt. Triggers zijn permanent, behalve wanneer het trefwoord TEMP of TEMPORARY is gebruikt. In dat geval wordt de trigger verwijderd wanneer de verbinding met de hoofddatabase van de SQLConnection-instantie wordt gesloten. Als er geen tijdsbepaling is opgegeven (BEFORE of AFTER), wordt de trigger standaard ingesteld op BEFORE.

Alleen triggers van het type FOR EACH ROW worden ondersteund, waardoor de tekst FOR EACH ROW optioneel is. Bij een trigger van het type FOR EACH ROW worden de trigger-stepinstructies uitgevoerd voor elke databaserij die wordt ingevoegd, bijgewerkt of verwijderd door de instructie die de trigger activeert, als de expressie van de WHEN-component wordt geëvalueerd als true.

Als een WHEN-component wordt opgegeven, worden de als triggerstappen opgegeven SQL-instructies alleen uitgevoerd voor rijen waarvoor de WHEN-component waar is. Als er geen WHEN-component is opgegeven, worden de SQL-instructies uitgevoerd voor alle rijen.

Binnen de tekst van een trigger (de component trigger-action) zijn de waarden vóór de wijziging en die van na de wijziging van de onderworpen tabel beschikbaar met de speciale tabelnamen OLD en NEW. De structuur van de tabellen OLD en NEW komt overeen met de structuur van de tabel waarvoor de trigger werd gemaakt. De tabel OLD bevat die rijen die zijn gewijzigd of verwijderd door de activerende instructie, zoals ze waren vóór de bewerkingen van de activerende instructie. De tabel NEW bevat die rijen die zijn gewijzigd of gemaakt door de activerende instructie, zoals ze zijn na de bewerkingen van de activerende instructie. Zowel de WHEN-component als de trigger-stepinstructies hebben toegang tot waarden uit de rij die wordt ingevoegd, verwijderd of bijgewerkt door middel van verwijzingen in de vorm van NEW.column-name en OLD.column-name, waarbij column-name de naam is van een kolom uit de tabel waaraan de trigger is gekoppeld. De beschikbaarheid van de tabelverwijzingen OLD en NEW is afhankelijk van het type database-event waarmee de trigger werkt:

• INSERT – NEW-verwijzingen zijn geldig

• UPDATE – NEW en OLD-verwijzingen zijn geldig

• DELETE – OLD-verwijzingen zijn geldig

De opgegeven tijdsbepaling (BEFORE, AFTER of INSTEAD OF) bepaalt wanneer de trigger-stepinstructies worden uitgevoerd ten opzichte van invoeging, wijziging of verwijdering van de gekoppelde rij. Een ON CONFLICT-component kan worden opgegeven als onderdeel van een instructie UPDATE of INSERT in een trigger-step. Als een ON CONFLICT-component echter wordt opgegeven als onderdeel van de instructie die ertoe leidt dat de trigger wordt geactiveerd, wordt in plaats daarvan het conflictoplossingsbeleid gebruikt.

Naast tabeltriggers kan een trigger van het type INSTEAD OF worden gemaakt voor een weergave. Als een of meer triggers van het type INSTEAD OF INSERT, INSTEAD OF DELETE of INSTEAD OF UPDATE worden gedefinieerd voor een weergave, wordt het niet als onjuist beschouwd om het bijbehorende type instructie (INSERT, DELETE of UPDATE) uit te voeren op de weergave. In dat geval leidt de uitvoering van een INSERT, DELETE of UPDATE op de weergave tot activering van de gekoppelde triggers. Aangezien de trigger een INSTEAD OF-trigger is, worden de tabellen die ten grondslag liggen aan de weergave, niet gewijzigd door de instructie die de activering van de trigger heeft veroorzaakt. De triggers kunnen echter worden gebruikt voor het uitvoeren van wijzigende bewerkingen op de onderliggende tabellen.

Als u een trigger voor een tabel met een kolom INTEGER PRIMARY KEY maakt, moet u rekening houden met het volgende. Als een trigger van het type BEFORE de kolom INTEGER PRIMARY KEY wijzigt van een rij die wordt bijgewerkt door de instructie die activering van de trigger heeft veroorzaakt, vindt er geen bijwerking plaats. Een oplossing is het maken van de tabel met een kolom PRIMARY KEY in plaats van een kolom INTEGER PRIMARY KEY.

Een trigger kan worden verwijderd met behulp van de instructie DROP TRIGGER. Wanneer een tabel of weergave wordt verwijderd, worden ook automatisch alle triggers verwijderd die zijn gekoppeld aan die tabel of weergave.

RAISE()-functie

Een speciale SQL-functie RAISE() kan worden gebruikt in een trigger-stepinstructie van een trigger. Deze functie heeft de volgende syntaxis:

raise-function  ::=  RAISE ( ABORT, error-message ) | 
                     RAISE ( FAIL, error-message ) | 
                     RAISE ( ROLLBACK, error-message ) | 
                     RAISE ( IGNORE )

Wanneer een van de eerste drie vormen wordt aangeroepen tijdens het uitvoeren van de trigger, wordt de opgegeven ON CONFLICT-verwerkingsactie (ABORT, FAIL of ROLLBACK) uitgevoerd en wordt het uitvoeren van de huidige instructie beëindigd. De ROLLBACK wordt beschouwd als een fout bij het uitvoeren van de instructie, waardoor de SQLStatement-instantie waarvan de methode execute() werd uitgevoerd, een gebeurtenis error (SQLErrorEvent.ERROR) verzendt. Van het SQLError-object in de eigenschap error van het verzonden gebeurtenisobject wordt de eigenschap details ingesteld op het error-message die is opgegeven in de functie RAISE().

Wanneer RAISE(IGNORE) wordt aangeroepen, worden het restant van de huidige trigger, de instructie die uitvoering van de trigger heeft veroorzaakt, en alle daaropvolgende triggers die zouden zijn uitgevoerd, afgebroken. Er worden geen databasewijzigingen teruggedraaid. Als de instructie die uitvoering van de trigger heeft veroorzaakt, zelf onderdeel van een trigger is, wordt de uitvoering van het triggerprogramma hervat bij het begin van de volgende stap. Zie het gedeelte ON CONFLICT (conflictalgoritmen) voor meer informatie over algoritmen voor het oplossen van conflicten.

DROP TRIGGER

De instructie DROP TRIGGER verwijdert een trigger die is gemaakt met de instructie CREATE TRIGGER.

sql-statement  ::=  DROP TRIGGER [IF EXISTS] [database-name.] trigger-name

De trigger wordt verwijderd uit de database. Denk eraan dat triggers automatisch worden verwijderd wanneer de tabel waaraan ze zijn gekoppeld wordt verwijderd.

COLLATE

De component COLLATE wordt gebruikt in instructies van het type SELECT, CREATE TABLE en CREATE INDEX om het vergelijkingsalgoritme op te geven dat wordt gebruikt bij het vergelijken of sorteren van waarden.

sql-statement   ::=  COLLATE collation-name 
collation-name  ::=  BINARY | NOCASE

Het standaardsorteertype voor kolommen is BINARY. Wanneer de sortering BINARY wordt gebruikt bij waarden van de opslagklasse TEXT, wordt binaire sortering uitgevoerd door de bytes in het geheugen die de waarde vertegenwoordigen te vergelijken ongeacht de tekstcodering.

De sorteervolgorde NOCASE wordt alleen toegepast op waarden van de opslagklasse TEXT. Bij gebruik wordt bij de sortering NOCASE geen onderscheid gemaakt tussen hoofdletters en kleine letters.

Er wordt geen sorteervolgorde gebruik voor opslagklassen van het type NULL, BLOB, INTEGER of REAL.

Voor het gebruik van een ander sorteertype dan BINARY bij een kolom moet een COLLATE-component worden opgegeven als onderdeel van de kolomdefinitie in de instructie CREATE TABLE. Wanneer twee TEXT-waarden worden vergeleken, wordt een sorteervolgorde gebruikt om in overeenstemming met de volgende regels de resultaten van de vergelijking vast te stellen:

EXPLAIN

De opdrachtmodifier EXPLAIN is een niet-standaard uitbreiding op SQL.

sql-statement  ::=  EXPLAIN sql-statement

Als het trefwoord EXPLAIN voorkomt vóór een andere SQL-instructie, wordt de instructie feitelijk niet uitgevoerd, maar meldt het resultaat de volgorde van virtuele machine-instructies die zouden zijn gebruikt bij de uitvoering van die instructie, als het trefwoord EXPLAIN niet aanwezig was geweest. De functie EXPLAIN is een geavanceerde functie waarmee ontwikkelaars tekst in SQL-instructies kunnen wijzigen voor het optimaliseren van prestaties of voor foutopsporing in een instructie die niet goed lijkt te functioneren.

ON CONFLICT (conflictalgoritmen)

De component ON CONFLICT is geen afzonderlijke SQL-instructie. Het betreft een niet-standaard component die in vele andere SQL-instructies kan voorkomen.

conflict-clause     ::=  ON CONFLICT conflict-algorithm 
conflict-clause     ::=  OR conflict-algorithm 
conflict-algorithm  ::=  ROLLBACK | 
                         ABORT | 
                         FAIL | 
                         IGNORE | 
                         REPLACE

De eerste vorm van de component ON CONFLICT, die de trefwoorden ON CONFLICT gebruikt, wordt gebruikt in een instructie CREATE TABLE. Voor een instructie INSERT of UPDATE wordt de tweede vorm gebruikt, waarbij ON CONFLICT wordt vervangen door OR om de syntaxis natuurlijker te doen lijken. In plaats van INSERT ON CONFLICT IGNORE wordt de instructie bijvoorbeeld INSERT OR IGNORE. Hoewel de trefwoorden anders zijn, is de betekenis van de component in beide gevallen gelijk.

De component ON CONFLICT bepaalt welk algoritme wordt gebruikt voor het oplossen van beperkingsconflicten. De vijf algoritmen zijn ROLLBACK, ABORT, FAIL, IGNORE en REPLACE. Het standaardalgoritme is ABORT. Hierna volgt een beschrijving van de vijf conflictalgoritmen:

ROLLBACK

Wanneer er een schending van een beperking optreedt, leidt dit tot een onmiddellijke ROLLBACK en wordt de huidige transactie beëindigd. De instructie wordt afgebroken en de SQLStatement-instantie verzendt een error-gebeurtenis. Als er geen transactie actief is (behalve de geïmpliceerde transactie die bij elke instructie wordt gemaakt), werkt dit algoritme hetzelfde als ABORT.

ABORT

Wanneer er een schending van een beperking optreedt, maakt de instructie alle eventuele, reeds aangebrachte wijzigingen ongedaan en verzendt de SQLStatement-instantie een error-gebeurtenis. Er wordt geen ROLLBACK uitgevoerd, waardoor de wijzigingen van eerdere instructies binnen een transactie behouden blijven. ABORT is het standaardgedrag.

FAIL

Wanneer er een schending van een beperking optreedt, wordt de instructie afgebroken en verzendt de SQLStatement-instantie een error-gebeurtenis. Alle wijzigingen aan de database die de instructie heeft aangebracht voordat de schending van de beperking zich voordeed, blijven echter behouden en worden niet ongedaan gemaakt. Als een UPDATE-instructie bijvoorbeeld een schending van een beperking opmerkt in de 100e rij die deze probeert bij te werken, blijven de wijzigingen in de eerste 99 rijen behouden, maar vinden er geen wijzigingen in rij 100 en daaropvolgende rijen plaats.

IGNORE

Wanneer er een schending van een beperking optreedt, wordt die ene rij waarin de schending van een beperking zich voordeed, niet ingevoegd of gewijzigd. Met uitzondering van het negeren van deze rij wordt de rest van de instructie normaal uitgevoerd. Andere rijen vóór en na de rij met de schending van de beperking worden normaal ingevoegd of bijgewerkt. Er wordt geen fout geretourneerd. Er wordt geen fout geretourneerd.

REPLACE

Wanneer er een schending UNIQUE van een beperking optreedt, worden de reeds bestaande rijen die de schending van de beperking veroorzaken, eerst verwijderd voordat de huidige wordt ingevoegd of bijgewerkt. Hierdoor vindt het invoegen of bijwerken altijd plaats en wordt de instructie normaal uitgevoerd. Er wordt geen fout geretourneerd. Als zich een schending van een NOT NULL-beperking voordoet, wordt de waarde NULL vervangen door de standaardwaarde voor die kolom. Als de kolom geen standaardwaarde heeft, wordt het algoritme ABORT gebruikt. Als zich een schending van een CHECK-beperking voordoet, wordt het algoritme IGNORE gebruikt. Wanneer deze conflictoplossingsstrategie rijen verwijdert om aan een beperking te voldoen, worden voor deze rijen geen triggers voor verwijderen geactiveerd.

Het algoritme dat is opgegeven in de OR-component van een INSERT- of UPDATE-instructie heeft voorrang op algoritmen die zijn opgegeven in een CREATE TABLE-instructie. Als er geen algoritme is opgegeven in de instructie CREATE TABLE of de uitvoerende instructie INSERT of UPDATE, wordt het algoritme ABORT gebruikt.

REINDEX

De instructie REINDEX wordt gebruikt voor het verwijderen en opnieuw maken van een of meer indices. Deze instructie is handig wanneer de definitie van een sorteervolgorde is gewijzigd.

sql-statement  ::=  REINDEX collation-name 
sql-statement  ::=  REINDEX [database-name .] ( table-name | index-name )

Bij de eerste vorm worden alle indices in alle gekoppelde databases die de genoemde sorteervolgorde gebruiken, opnieuw gemaakt. Bij de tweede vorm, wanneer een table-name wordt opgegeven, worden alle indices die aan de tabel zijn gekoppeld, opnieuw samengesteld. Als er een index-name is opgegeven, wordt alleen de opgegeven index verwijderd en opnieuw gemaakt.

OPMERKINGEN

Opmerkingen zijn geen SQL-instructies, maar kunnen wel voorkomen in SQL-query's. Ze worden door de runtime als witruimte beschouwd. Ze kunnen beginnen overal waar witruimte kan worden gevonden, inclusief binnen expressies die meerdere regels beslaan.

comment             ::=  single-line-comment | 
                         block-comment 
single-line-comment ::=  -- single-line 
block-comment       ::=  /* multiple-lines or block [*/]

Een opmerking van één regel wordt aangegeven met twee liggende streepjes. Een opmerking van één regel loopt slechts tot het einde van de huidige regel.

Blokopmerkingen kunnen een willekeurig aantal regels beslaan of kunnen zijn ingebed binnen één regel. Als er geen beëindigend scheidingsteken is, loopt een blokopmerking door tot aan het einde van de invoer. Deze situatie wordt niet als een fout gezien. Een nieuwe SQL-instructie kan beginnen op een regel nadat een blokopmerking is geëindigd. Blokopmerkingen kunnen overal waar witruimte kan voorkomen worden ingesloten, inclusief binnen expressies en te midden van andere SQL-instructies. Blokopmerkingen kunnen niet worden genest. Opmerkingen van één regel binnen een blokopmerking worden genegeerd.

EXPRESSIES

Expressies zijn subopdrachten binnen andere SQL-blokken. Hierna volgt een beschrijving van de geldige syntaxis voor een expressie binnen een SQL-instructie:

expr            ::=  expr binary-op expr | 
                     expr [NOT] like-op expr [ESCAPE expr] | 
                     unary-op expr | 
                     ( expr ) | 
                     column-name | 
                     table-name.column-name | 
                     database-name.table-name.column-name | 
                     literal-value | 
                     parameter | 
                     function-name( expr-list | * ) | 
                     expr ISNULL | 
                     expr NOTNULL | 
                     expr [NOT] BETWEEN expr AND expr | 
                     expr [NOT] IN ( value-list ) | 
                     expr [NOT] IN ( select-statement ) | 
                     expr [NOT] IN [database-name.] table-name | 
                     [EXISTS] ( select-statement ) | 
                     CASE [expr] ( WHEN expr THEN expr )+ [ELSE expr] END | 
                     CAST ( expr AS type ) | 
                     expr COLLATE collation-name 
like-op         ::=  LIKE | GLOB 
binary-op       ::=  see Operators 
unary-op        ::=  see Operators 
parameter       ::=  :param-name | @param-name | ? 
value-list      ::=  literal-value [, literal-value]* 
literal-value   ::=  literal-string | literal-number | literal-boolean | literal-blob | literal-null 
literal-string  ::=  'string value' 
literal-number  ::=  integer | number 
literal-boolean  ::=  true | false 
literal-blob  ::=  X'string of hexadecimal data' 
literal-null  ::=  NULL

Een expressie is een willekeurige combinatie van waarden en operatoren die resulteert in één waarde. Expressies kunnen worden onderverdeeld in twee algemene typen, op basis van of ze resulteren in een booleaanse waarde (waar of onwaar), of in een niet-booleaanse waarde.

In verscheidene veelvoorkomende situaties, inclusief in een WHERE-component, een HAVING-component, de expressie ON in een JOIN-component of een CHECK-expressie, moet de expressie resulteren in een booleaanse waarde. De volgende typen expressies voldoen aan deze voorwaarde:

• ISNULL

• NOTNULL

• IN ()

• EXISTS ()

• LIKE

• GLOB

• Bepaalde functies

• Bepaalde operatoren (in het bijzonder vergelijkingsoperatoren)

Letterlijke waarden

Een letterlijke numeriek waarde wordt geschreven is als geheel getal of als een zwevende-kommagetal. Wetenschappelijke notatie wordt ondersteund. De . (punt) wordt altijd gebruikt als decimaalteken.

Een letterlijke tekenreeks wordt aangeduid door de tekenreeks tussen enkele aanhalingstekens ' te zetten. Als u een enkel aanhalingsteken in een tekenreeks wilt opnemen, plaatst u twee enkele aanhalingstekens achter elkaar ('').

Een booleaanse letterlijke waarde wordt aangeduid door de waarde true of false. Letterlijke booleaanse waarden worden gebruikt bij het kolomgegevenstype Booleaans.

Een BLOB is een letterlijke tekenreeks met hexadecimale gegevens, die wordt voorafgegaan door één teken x of X, zoals X'53514697465'.

Een letterlijke waarde kan ook bestaan uit het token NULL.

Kolomnaam

Een kolomnaam kan elk van de namen zijn, die zijn gedefinieerd in de instructie CREATE TABLE, of een van de volgende speciale ID's: ROWID, OID, of _ROWID_. Deze speciale ID's beschrijven alle de unieke willekeurige sleutel van gehele getallen (de rijsleutel) die is gekoppeld aan elke rij van elke tabel. De speciale ID's verwijzen alleen naar de rijsleutel als de instructie CREATE TABLE geen echte kolom met dezelfde naam definieert. Rijsleutels gedragen zich als alleen-lezen kolommen. Een rijsleutel kan worden gebruikt overal waar een standaardkolom kan worden gebruikt, met deze uitzondering dat u de waarde van een rijsleutel niet kunt wijzigen in een UPDATE- of INSERT-instructie. De instructie SELECT * FROM table bevat geen rijsleutel in de bijbehorende resultatenset.

Instructie SELECT

Een SELECT-instructie kan voorkomen in een expressie als rechteroperand van de operator IN, als scalaire hoeveelheid (één resultaatwaarde) of als operand van een EXISTS-operator. Bij gebruik als scalaire hoeveelheid of als operand van een IN-operator kan de SELECT slechts één kolom in het resultaat hebben. Een samengestelde SELECT-instructie (die is verbonden door trefwoorden zoals UNION of EXCEPT) is toegestaan. Met de operator EXISTS worden de kolommen in de resultatenset van de SELECT genegeerd en retourneert de expressie TRUE als er een of meer rijen zijn, en FALSE als de resultatenset leeg is. Als er geen termen in de SELECT-expressie verwijzen naar de waarde in de bevattende query, wordt de expressie één maal geëvalueerd voordat er verdere verwerking plaatsvindt, en wordt het resultaat desnoods opnieuw gebruikt. Als de expressie SELECT geen variabelen bevat van de buitenste query (beter bekend als een gecorreleerde subquery), wordt de SELECT telkens wanneer dit nodig is, opnieuw geëvalueerd.

Wanneer een SELECT de rechteroperand van de operator IN is, geeft de operator IN TRUE als resultaat als het resultaat van de linkeroperand gelijk is aan een van de waarden in de resultatenset van de instructie SELECT. De operator IN kan worden voorafgegaan door het trefwoord NOT om de bedoeling van de test om te keren.

Wanneer een SELECT wel voorkomt binnen een expressie, maar niet als rechteroperand van een IN-operator, wordt de eerst rij van het resultaat van de SELECT de waarde die wordt gebruikt in de expressie. Als de SELECT meer dan één resultaatrij geeft, worden alle rijen na de eerste rij genegeerd. Als de SELECT geen rijen geeft, is de waarde van de SELECT NULL.

Expressie CAST

Een CAST-expressie wijzigt het opgegeven gegevenstype in het gegevenstype dat is gegeven. Het opgegeven type kan elke niet-lege typenaam zijn die geldig is voor het type in een kolomdefinitie van een CREATE TABLE-instructie. Zie Ondersteuning van gegevenstypen voor meer informatie.

Aanvullende expressie-elementen

De volgende SQL-elementen kunnen ook worden gebruikt in expressies:

• Ingebouwde functies: statistische functies, scalaire functies en datum- en tijdnotatiefuncties

• Operatoren

• Parameters

Statistische functies

Statistische functies voeren bewerkingen uit op waarden uit meerdere rijen. Deze functies worden voornamelijk gebruikt in SELECT-instructies in combinatie met de component GROUP BY.

In elke van de voorafgaande statistische functies met één argument kan dat argument worden voorafgegaan door het trefwoord DISTINCT. In dat geval worden dubbele elementen gefilterd voordat ze worden doorgegeven aan de statistische functie. Zo retourneert de functieaanroep COUNT(DISTINCT x) het aantal afzonderlijke waarden in kolom X, in plaats van het totaalaantal niet-NULL-waarden in kolom x.

Scalaire functies

Scalaire functies bewerken waarden met één rij per keer.

Datum- en tijdnotatiefuncties

De datum- en tijdnotatiefuncties vormen een groep scalaire functies die worden gebruikt voor het maken van opgemaakte datum- en tijdgegevens. Houd er rekening mee dat deze functies tekenreeks- en getalwaarden bewerken en retourneren. Deze functies zijn niet bedoeld voor gebruik in combinatie met het gegevenstype DATE. Bij gebruik van deze functies voor gegevens in een kolom waarvan het gedeclareerde gegevenstype DATE is, gedragen zij zich niet zoals verwacht.

Tijdnotaties

Het teken T in deze notaties is een letterteken "T" dat de datum en de tijd scheidt. Notaties met daarin alleen een tijd gaan uit van de datum 01-01-2001.

Modifiers

Algemene operatoren

De volgende binaire operatoren zijn toegestaan in een SQL-blok en worden vermeld in de volgorde van hoogste naar laagste voorrang:

*    /    % 
+    - 
<< >> &     | 
< >=   > >= 
=    ==   !=   <> IN 
AND 
OR

Ondersteunde unaire prefixoperatoren (voorvoegseloperatoren) zijn:

 !    ~    NOT

De operator COLLATE kan worden beschouwd als een unaire postfixoperator (achtervoegseloperator). De operator COLLATE heeft de hoogste voorrang. Deze bindt altijd hechter dan elke andere unaire prefixoperator of elke andere binaire operator.

Denk eraan dat er twee varianten zijn van de operatoren equals (is gelijk aan) en unequals (is niet gelijk aan). Equals (is gelijk aan) kan = of == zijn. De operator not equals (is niet gelijk aan) kan != of <> zijn.

De operator || is een tekenreekssamenvoegingsoperator: deze voegt twee tekenreeksen van zijn operanden samen.

De operator % geeft als uitvoer het restant van de linkeroperand modulo de rechteroperand.

Het resultaat van elke binaire operator is een numerieke waarde, behalve voor de samenvoegingsoperator || die een tekenreeksresultaat geeft.

SQL-operatoren

LIKE

De operator LIKE voert een vergelijking van patroonovereenkomsten uit.

expr     ::=  (column-name | expr) LIKE pattern 
pattern  ::=  '[ string | % | _ ]'

De operand rechts van de operator LIKE bevat het patroon en de linkeroperator bevat de tekenreeks die met het patroon moet worden vergeleken. Een percentageteken (%) in het patroon is een jokerteken: het komt overeen met een willekeurige reeks van nul of meer tekens in de tekenreeks. Een onderstrepingsteken (_) in het patroon komt overeen met één willekeurig letterteken in de tekenreeks. Elk ander letterteken komt overeen met zichzelf of zijn equivalent in hoofdletter/kleine letter. Dat betekent dat geen onderscheid wordt gemaakt tussen hoofdletters en kleine letters bij het zoeken naar overeenkomsten. (Opmerking: de database-engine kan alleen hoofdletters/kleine letters voor 7-bits Latijnse lettertekens interpreteren. Daarom is de operator LIKE hoofdlettergevoelig voor 8-bits, iso-8859-lettertekens of UTF-8-lettertekens. Zo geeft de expressie 'a' LIKE 'A' als resultaat TRUE, maar geeft 'æ' LIKE 'Æ' als resultaat FALSE.) Hoofdlettergevoeligheid voor Latijnse lettertekens kan worden gewijzigd met behulp van de eigenschap SQLConnection.caseSensitiveLike.

Als de optionele component ESCAPE aanwezig is, moet de expressie die volgt op het trefwoord ESCAPE, worden geëvalueerd met een tekenreeks die uit één letterteken bestaat. Dit letterteken kan worden gebruikt in het patroon LIKE voor het zoeken naar overeenkomsten met letterlijke percentage- of onderstrepingstekens. Het escape-teken gevolgd door een percentageteken, onderstrepingsteken of zichzelf komt overeen met respectievelijk een letterlijk percentageteken, onderstrepingsteken of escape-teken in de tekenreeks.

GLOB

De operator GLOB komt overeen met LIKE, maar gebruikt voor zijn jokertekens de globbingsyntaxis voor Unix-bestanden. In tegenstelling tot LIKE is GLOB wel hoofdlettergevoelig.

IN

De operator IN berekent of de linkeroperand gelijk is aan een van de waarden in de rechteroperand (een reeks waarden tussen haakjes).

in-expr         ::=  expr [NOT] IN ( value-list ) | 
                     expr [NOT] IN ( select-statement ) | 
                     expr [NOT] IN [database-name.] table-name 
value-list      ::=  literal-value [, literal-value]*

De rechteroperand kan bestaan uit een reeks met komma's gescheiden letterlijke waarden of kan het resultaat zijn van een SELECT-instructie. Zie de SELECT-instructies in expressies voor een uitleg en de beperkingen bij het gebruik van de instructie SELECT als rechteroperand van de operator IN.

BETWEEN...AND

De operator BETWEEN...AND is gelijk aan het gebruik van twee expressies met de operatoren >= en <=. Zo is de expressie x BETWEEN y AND z equivalent aan x >= y AND x <= z.

NOT

De operator NOT is een ontkenningsoperator. De operatoren GLOB, LIKE en IN kunnen worden voorafgegaan door het trefwoord NOT om de betekenis van de test om te keren (dat wil zeggen om te controleren of een waarde niet overeenkomt met het opgegeven patroon).