SQL-syntax som stöds

SELECT

Programsatsen SELECT används för att köra databasfrågor. Resultatet av en SELECT-sats är noll eller flera rader med data, där varje rad har ett fast antal kolumner. Antal kolumner i resultatet specificeras i resultatkolumnnamnet eller i uttryckslistan mellan SELECT och valfria FROM-nyckelord.

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

Vilket godtyckligt uttryck som helst kan användas som ett resultat. Om ett resultatuttryck är * ersätts alla kolumner i tabellen med det uttrycket. Om uttrycket är namnet på en tabell följt av *, är resultatet alla kolumner i just den tabellen.

Nyckelordet DISTINCT gör att en delmängd av resultatraderna returneras, där alla raderna är unika. NULL-värden behandlas inte som om de skiljer sig från varandra. Standardbeteendet är att alla resultatrader skickas tillbaka, vilket kan förtydligas med nyckelordet ALL.

Databasfrågan körs mot en eller flera tabeller som anges efter nyckelordet FROM. Om flera tabellnamn avgränsas med kommatecken returneras alla poster i de olika tabellerna med en korskoppling (cross join). JOIN-syntaxen kan också användas för att specificera hur tabellerna kopplas. Den enda typen av yttre koppling (outer join) som stöds är LEFT OUTER JOIN. Satsuttrycket ON i join-args måste kunna evalueras som ett booleskt värde. En underfråga inom parentes kan användas som en tabell i FROM-satsen. Hela FROM-satsen kan utelämnas och i så fall blir resultatet en enkel rad bestående av värdena i resultatuttryckslistan.

Satsuttrycket WHERE används för att begränsa det antal rader som frågan hämtar. WHERE-satsuttrycken måste kunna evalueras som ett booleskt värde. WHERE-satsfiltreringen utförs före gruppering, vilket innebär att WHERE-satsuttrycken inte kan innehålla sammanställningsfunktioner.

Satsen GROUP BY gör att en eller flera resultatrader kombineras till en enda utdatarad. En GROUP BY-sats är speciellt användbar om resultatet innehåller sammanställningsfunktioner. Uttrycken i GROUP BY-satsen behöver inte vara uttryck som visas i SELECT-uttryckslistan.

HAVING-satsen fungerar på samma sätt som WHERE i den bemärkelsen att den begränsar det antal rader som returneras av programsatsen. HAVING-satsen tillämpas däremot efter att en gruppering som har specificerats av GROUP BY har skett. Följaktligen kan HAVING-uttrycket referera till värden som inkluderar sammanställningsfunktioner. Det behöver inte finnas ett HAVING-satsuttryck i SELECT-listan. Precis som ett WHERE-uttryck måste ett HAVING-uttryck kunna resultera i ett booleskt värde.

ORDER BY-satsen sorterar de utgående raderna. Argumentet sort-expr-list för ORDER BY-satsen är en lista med uttryck som används som nyckel för sorteringen. Uttrycken behöver inte vara del av resultatet för en enkel SELECT, men i en sammansatt SELECT (en SELECT använder en av compound-op-operatorerna) måste varje uttryck exakt matcha en av resultatkolumnerna. Varje sorteringsuttryck kan följas av en sort-order-sats bestående av COLLATE-nyckelord och namnet på en kollationsfunktion som används för att sortera text och/eller nyckelordet ASC eller DESC för att specificera sorteringsordning (stigande eller fallande). sort-order kan utelämnas, och då används standardordningen (stigande ordning). En definition av COLLATE-satsen och kollationsfunktioner finns i COLLATE.

LIMIT-satsen sätter en övre gräns för de antal rader som returneras i resultatet. Ett negativt LIMIT-värde betyder att det inte finns någon övre gräns. OFFSET efter LIMIT används för att specificera hur många rader som ska hoppas över i början av resultatet. I en sammansatt SELECT-fråga kan LIMIT-satsen endast visas efter den slutliga SELECT-programsatsen och begränsningen gäller då för hela frågan. Observera, att om nyckelordet OFFSET används i LIMIT-satsen, är gränsen det första heltalet och förskjutningen det andra heltalet. Om ett komma används i stället för nyckelordet OFFSET, är förskjutningen den första siffran och gränsen den andra siffran. Den här inkonsekvensen är avsiktlig, eftersom den maximerar kompatibiliteten med äldre SQL-databassystem.

En sammansatt SELECT är uppbyggd av två eller flera enkla SELECT-satser som förenas med någon av operatorerna UNION, UNION ALL, INTERSECT eller EXCEPT. I en sammansatt SELECT måste alla SELECT-satserna specificera samma antal resultatkolumner. Det får bara finnas en ORDER BY-sats efter den slutliga SELECT-programsatsen (och före LIMIT-satsen, om den finns med). Operatorerna UNION och UNION ALL kombinerar resultatet från föregående och efterföljande SELECT-satser i en enda tabell. Skillnaden är, att i UNION är alla resultatrader distinkta, till skillnad från UNION ALL där det kan finnas dubbletter. Operatorn INTERSECT ger snittet av den föregående och efterföljande SELECT-programsatsen. EXCEPT ger resultatet av föregående SELECT efter att ha tagit bort resultatet av efterföljande SELECT. Om tre eller flera SELECT-programsatser är sammankopplade, grupperas de från första till sista resultatmängd.

En definition av tillåtna uttryck finns i Uttryck.

Från och med AIR 2.5 stöds SQL CAST-operatorn vid läsning för att konvertera BLOB-data till ActionScript ByteArray-objekt. Följande kod läser till exempel rådata som inte sparas i AMF-format och sparar dessa i ett ByteArray-objekt:

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

Den första formen (med nyckelordet VALUES) skapar en ny rad i en befintlig tabell. Om ingen column-list har angetts, måste antalet värden vara detsamma som antalet kolumner i tabellen. Om en column-list har angetts, måste antalet värden matcha antalet specificerade kolumner. Kolumner i tabellen som inte finns med i kolumnlistan fylls med de standardvärden som definierades när tabellen skapades, eller med NULL om inget standardvärde är definierat.

Den andra formen av INSERT hämtar data från en SELECT-programsats. Antal kolumner i resultatet av SELECT-uttrycket måste exakt matcha antalet kolumner i tabellen, om column-list inte har angetts, eller så måste det matcha antalet kolumner som är namngivna i kolumnlistan. En ny post skapas i tabellen för varje resultatrad från SELECT-uttrycket. SELECT-uttrycket kan vara enkelt eller sammansatt. En definition av tillåtna SELECT-programsatser finns i SELECT.

Det valfria uttrycket conflict-algorithm tillåter en specifikation av en alternativ begränsad konfliktlösningsalgoritm som kan användas under detta kommando. Du hittar förklaringar och definitioner av konfliktalgoritmer i avsnittet Särskilda programsatser och klausuler .

De två REPLACE INTO-formerna av programsatsen motsvarar att använda INSERT [OR conflict-algorithm]-standardformen med konfliktalgoritmen REPLACE (d.v.s. INSERT OR REPLACE...).

De två REPLACE INTO-formerna av programsatsen motsvarar att använda INSERT [OR conflict-algorithm]-standardformen med konfliktalgoritmen REPLACE (d.v.s. INSERT OR REPLACE...).

UPDATE

Uppdateringskommandot ändrar de befintliga posterna i en tabell.

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

Kommandot består av nyckelordet UPDATE följt av namnet på den tabell vars poster ska uppdateras. Efter nyckelordet SET anger du namnet på kolumnen och det värde som kolumnen ska ändras till som en kommaavgränsad lista. WHERE-satsuttrycket tillhandahåller den eller de rader i vilka poster uppdateras.

DELETE

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

Kommandot består av nyckelordet DELETE FROM följt av namnet på den tabell från vilken posterna ska tas bort.

Utan en WHERE-sats tas alla rader i tabellen bort. Om en WHERE-sats finns med, tas endast rader som matchar uttrycket bort. WHERE-satsuttrycken måste kunna evalueras som ett booleskt värde. En definition av tillåtna uttryck finns i Uttryck.

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

Varje kolumndefinition är namnet på kolumnen följt av kolumnens datatyp och sedan en eller flera valfria kolumnbegränsningar. Kolumnens datatyp bestämmer vilka data som kan lagras i den kolumnen. Om det görs ett försök att lagra ett värde i en kolumn med en annan datatyp, kommer körningsbiblioteket att konvertera värdet till lämplig typ, om detta är möjligt. Går det inte att konvertera värdet genereras ett fel. Mer information finns i avsnittet Datatyper som stöds.

Kolumnbegränsningen NOT NULL anger att kolumnen inte får innehålla NULL-värden.

En UNIQUE-begränsning innebär att ett index skapas för en eller flera kolumner. Det här indexet måste innehålla unika nycklar, två rader får inte innehålla dubbla värden eller kombinationer av värden för den specificerade kolumnen eller kolumnerna. En CREATE TABLE-sats kan ha flera UNIQUE-begränsningar, inklusive flera kolumner med en UNIQUE-begränsning i kolumnens definition och/eller flernivåers UNIQUE-begränsningar.

En CHECK-begränsning definierar ett uttryck som är evaluerat och måste vara sant för att dataraden ska läggas till eller uppdateras. CHECK-uttrycket måste evalueras som ett booleskt värde.

En COLLATE-sats i en kolumndefinition specificerar vilken textkollationsfunktion som används vid jämförelse av textposter i kolumnen. Som standard används sorteringsfunktionen BINARY. En definition av COLLATE-satsen och kollationsfunktioner finns i COLLATE.

Begränsningen DEFAULT specificerar ett standardvärde som ska användas vid en INSERT. Värdet kan vara NULL, en strängkonstant eller ett tal. Standardvärdet kan också vara ett av de särskilda nyckelorden CURRENT_TIME, CURRENT_DATE eller CURRENT_TIMESTAMP (inte skiftlägeskänsliga). Om värdet är NULL, en strängkonstant eller ett tal, infogas detta värde i kolumnen om en INSERT-sats inte specificerar ett värde för kolumnen. Om värdet är CURRENT_TIME, CURRENT_DATE eller CURRENT_TIMESTAMP infogas aktuellt UTC-datum och/eller klockslag i kolumnen. För CURRENT_TIME är formatet HH:MM:SS. För CURRENT_DATE är formatet YYYY-MM-DD. Formatet för CURRENT_TIMESTAMP är YYYY-MM-DD HH:MM:SS.

Om du anger en PRIMARY KEY skapas normalt ett UNIQUE-index på motsvarande kolumn eller kolumner. Om däremot PRIMARY KEY-begränsningen i en enkel kolumn har datatypen INTEGER (eller någon av dess synonymer så som int), används kolumnen av databasen som primärnyckelord för tabellen. Detta innebär att kolumnen endast kan innehålla unika heltalsvärden. (I många SQLite-implementeringar leder endast kolumntypen INTEGER till att kolumnen fungerar som intern primärnyckel, men i Adobe AIR anger synonymer för INTEGER så som int också detta beteende.)

Om tabellen inte har en INTEGER PRIMARY KEY-kolumn, kommer en heltalsnyckel att automatiskt genereras när raden infogas. Det går alltid att komma åt primärnyckeln för en rad med hjälp av specialnamnen ROWID, OID eller _ROWID_. Dessa namn kan användas oavsett om det finns en explicit deklarerad INTEGER PRIMARY KEY eller ett internt genererat värde. Om tabellen däremot har en explicit INTEGER PRIMARY KEY, är namnet på kolumnen i resultatdata det verkliga kolumnnamnet i stället för specialnamnet.

En INTEGER PRIMARY KEY-kolumn kan även innehålla nyckelordet AUTOINCREMENT. När AUTOINCREMENT-nyckelordet används genererar och infogar databasen automatiskt en heltalsnyckel i INTEGER PRIMARY KEY-kolumnen när en INSERT-programsats som inte specificerar ett värde för kolumnen utförs.

Det får endast finnas en PRIMARY KEY-begränsning i en CREATE TABLE-sats. Begränsningen kan antingen vara en del av kolumnens definition eller av en enkel PRIMARY KEY-begränsning. En primärnyckelkolumn är implicit NOT NULL.

Alternativet conflict-clause följt av flera begränsningar används för att ange en alternativ konfliktlösningsalgoritm som ska användas för den begränsningen. Standardvärdet är ABORT. Olika begränsningar inom samma tabell kan ha olika konfliktlösningsalgoritmer som standard. Om en INSERT- eller UPDATE-programsats specificerar en annan konfliktlösningsalgoritm, används den algoritmen på den plats som har angetts i programsatsen CREATE TABLE. Delen ON CONFLICT i Särskilda programsatser och klausuler innehåller mer information.

Ytterligare begränsningar, som begränsningen FOREIGN KEY, resulterar inte i ett fel men körningen ignorerar dem.

Om nyckelordet TEMP eller TEMPORARY finns mellan CREATE och TABLE visas den tabell som skapades endast inom samma databasanslutning (SQLConnection-instans). Den tas automatiskt bort när databasanslutningen stängs. Index som skapas på en temporär tabell är också temporära. Temporära tabeller och index lagras i separata filer skilt från huvuddatabasfilerna.

Om det valfria prefixet database-name är specificerat, skapas tabellen i en namngiven databas (en databas som var ansluten till SQLConnection-instansen genom att anropa metoden attach() med det specifika databasnamnet). Det är syntaktiskt fel att specificera både ett database-name-prefix och TEMP-nyckelordet såvida inte prefixet database-name är temp. Om inget databasnamn specificeras och TEMP-nyckelordet inte finns, skapas tabellen i huvuddatabasen (den databas som anslöts till SQLConnection-instansen med metoden open() eller openAsync()).

Det finns inga godtyckliga gränser för antal kolumner eller begränsningar i en tabell. Det finns heller ingen begränsning av mängden data i en rad.

Formen CREATE TABLE AS definierar tabellen som ett resultat av en fråga. Namnen på tabellkolumnerna är namnen på kolumnerna i resultatet.

Om den valfria IF NOT EXISTS-satsen finns med, och om en annan tabell med samma namn redan finns, kommer databasen att ignorera kommandot CREATE TABLE.

En tabell kan tas bort med programsatsen DROP TABLE och begränsade ändringar kan göras med programsatsen ALTER TABLE.

ALTER TABLE

Kommandot ALTER TABLE används för att byta namn på eller lägga till en ny kolumn i en befintlig tabell. Det går inte att ta bort en kolumn från en tabell.

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

Syntaxen RENAME TO används för att byta namn på den tabell som identifieras av [database-name.] table-name till new-table-name. Detta kommando kan inte användas för att flytta en tabell mellan databaser, utan endast för att byta namn på en tabell inom samma databas.

Om tabellen som byter namn har utlösare eller index, kommer dessa fortfarande att vara kopplade till tabellen efter namnbytet. Om det däremot finns vydefinitioner eller programsatser som aktiveras av utlösare, kommer de inte automatiskt att använda det nya tabellnamnet. Om en omdöpt tabell har associerade vyer eller utlösare, måste du manuellt ta bort och skapa nya utlösare eller vyer med det nya tabellnamnet.

Syntaxen ADD [COLUMN] används för att lägga till en ny kolumn i en befintlig tabell. Den nya kolumnen läggs alltid till efter de befintliga kolumnerna. Satsen column-def kan anta alla former som är tillåtna i en CREATE TABLE-programsats, med följande begränsningar:

• Kolumnen får inte ha begränsningarna PRIMARY KEY eller UNIQUE.

• Kolumnen får inte ha standardvärdet för CURRENT_TIME, CURRENT_DATE eller CURRENT_TIMESTAMP.

• Om en NOT NULL-begränsning har angetts, måste kolumnen ha ett annat standardvärde än NULL.

Körningstiden för programsatsen ALTER TABLE påverkas inte av mängden data i tabellen.

DROP TABLE

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

Som standard minskar inte programsatsen DROP TABLE storleken på databasfilen. Tomt utrymme i databasen bevaras och används i efterföljande INSERT-åtgärder. Använd metoden SQLConnection.clean() för att frigöra utrymme i databasen. Om parametern autoClean är inställd på true när databasen skapas, kommer utrymme att frigöras automatiskt.

Den valfria IF EXISTS-satsen undertrycker det fel som normalt genereras om tabellen inte existerar.

CREATE INDEX

Kommandot CREATE INDEX består av nyckelorden CREATE INDEX, följt av namnet på nytt index, nyckelordet ON, namnet på föregående tabell som ska indexeras och en lista inom parentes med namn på kolumner i tabellen vars värden ska användas för indexnyckeln.

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]

Varje kolumnnamn kan följas av nyckelorden ASC eller DESC för att indikera sorteringsordningen, men sorteringsordningen ignoreras av körningsbiblioteket. Sortering görs alltid i stigande ordning.

Satsen COLLATE efter varje kolumnnamn definierar den sorteringssekvens som används för textvärdet i den kolumnen. Standardkollationssekvensen är den kollationssekvens som är definierad för den kolumnen i programsatsen CREATE TABLE. Om ingen kollationssekvens är specificerad, används kollationssekvensen BINARY. En definition av COLLATE-satsen och kollationsfunktioner finns i COLLATE.

Det finns inga begränsningar för hur många index som kan kopplas till en enda tabell. Det finns inte heller några begränsningar för antalet kolumner i ett index.

DROP INDEX

Programsatsen DROP INDEX tar bort ett index som har lagts till med programsatsen CREATE INDEX. Det specificerade indexet raderas fullständigt från databasfilen. Det enda sättet att återskapa indexet är att köra motsvarande CREATE INDEX-kommando.

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

Som standard minskar inte programsatsen DROP INDEX storleken på databasfilen. Tomt utrymme i databasen bevaras och används i efterföljande INSERT-åtgärder. Använd metoden SQLConnection.clean() för att frigöra utrymme i databasen. Om parametern autoClean är inställd på true när databasen skapas, kommer utrymme att frigöras automatiskt.

CREATE VIEW

Kommandot CREATE VIEW tilldelar en fördefinierad SELECT-programsats ett namn. Det nya namnet kan sedan användas i en FROM-sats i en annan SELECT-programsats i stället för ett tabellnamn. Vyer används vanligtvis för att förenkla frågor genom att kombinera komplexa (och frekvent använda) datamängder i en struktur som kan användas i andra åtgärder.

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

Om nyckelordet TEMP eller TEMPORARY finns mellan CREATE och VIEW är vyn som skapas endast synlig för den SQLConnection-instans som öppnade databasen, och det tas bort automatiskt när databasen stängs.

Om [database-name] specificeras, skapas vyn i den namngivna databasen (den databas som var ansluten till SQLConnection-instansen med metoden attach()) med det specificerade name-argumentet. Det är syntaktiskt fel att specificera både [database-name] och TEMP om inte [database-name] är temp. Om inget databasnamn specificeras och TEMP-nyckelordet inte finns, skapas vyn i huvuddatabasen (den databas som anslöts till SQLConnection-instansen med metoden open() eller openAsync()).

Vyerna är skrivskyddade. Programsatserna DELETE, INSERT och UPDATE kan inte användas på en vy om inte minst en utlösare av motsvarande typ (INSTEAD OF DELETE, INSTEAD OF INSERT, INSTEAD OF UPDATE) har definierats. Mer information om hur du skapar en utlösare för en vy finns i CREATE TRIGGER.

En vy tas bort från databasen med programsatsen DROP VIEW.

DROP VIEW

Programsatsen DROP VIEW tar bort en vy som har skapats av en CREATE VIEW-programsats.

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

Uttrycket view-name är namnet på den vy som ska släppas. Den tas bort från databasen, men inga data i de underliggande tabellerna påverkas.

CREATE TRIGGER

Programsatsen CREATE TRIGGER används för att lägga till utlösare i databasschemat. En utlösare är en databasåtgärd (trigger-action) som automatiskt utförs när en specificerad databashändelse (database-event) inträffar.

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

En utlösare aktiveras när en DELETE, INSERT eller UPDATE för en viss databastabell inträffar, eller när en UPDATE av en eller flera specificerade kolumner i en tabell sker. Utlösare är permanenta om inte nyckelorden TEMP eller TEMPORARY används. I detta fall tas utlösaren bort när SQLConnection-instansens huvuddatabasanslutning stängs. Om ingen tidsinformation finns angiven (BEFORE eller AFTER) används standardvärdet BEFORE.

Endast FOR EACH ROW-utlösare stöds, och texten FOR EACH ROW är valfri. Med en FOR EACH ROW-utlösare körs programsatserna trigger-step för varje databasrad som infogas, uppdateras eller raderas av den programsats som aktiverade utlösaren. Detta sker när WHEN-satsuttrycket evalueras till true.

Om en WHEN-sats anges, kommer de SQL-programsatser som har specificerats som utlösarsteg endast att utföras för rader där WHEN-satsen är sann. Om en WHEN-sats saknas, körs SQL-programsatserna för alla rader.

Inom utlösarens definition (trigger-action-satsen) är värdena före och efter ändringarna av tabellen tillgängliga med hjälp av de särskilda tabellnamnen OLD och NEW. Strukturen på tabellerna OLD och NEW matchar strukturen på tabellen för vilken utlösaren skapas. OLD-tabellen innehåller alla rader som har ändrats eller raderats av utlösaren, med den status som gällde innan utlösaren aktiverades. Tabellen NEW innehåller alla rader som har ändrats eller skapats av utlösaren, med den status som gäller efter att utlösarens programsatser körts. Både WHEN-satsen och trigger-step-programsatserna har åtkomst till värdena från den rad som infogas, raderas eller uppdateras med hjälp av formen NEW.column-name och OLD.column-name, där column-name är namnet på en kolumn från den tabell som utlösaren hör till. Tillgängligheten för tabellreferenserna OLD och NEW beror på typen av database-event som utlösaren hanterar:

• INSERT – NEW-referenser är giltiga

• UPDATE – NEW- och OLD-referenser är giltiga

• DELETE – OLD-referenser är giltiga

Den specificerade tiden (BEFORE, AFTER eller INSTEAD OF) bestämmer när trigger-step-programsatser utförs i förhållande till infogning, ändring eller borttagning av den associerade raden. En ON CONFLICT-sats kan specificeras som en UPDATE- eller INSERT-programsats i ett trigger-step. Om en ON CONFLICT-sats däremot är en specificerad del av programsatsen som styr utlösaren, används i stället konflikthanteringsprincipen.

En INSTEAD OF-utlösare kan också skapas för en vy. Om en eller flera INSTEAD OF INSERT-, INSTEAD OF DELETE- eller INSTEAD OF UPDATE-utlösare definieras för en vy är det inte ett syntaktiskt fel att utföra associerade programsatstyper (INSERT, DELETE eller UPDATE) på vyn. I det fallet utförs en INSERT, DELETE eller UPDATE på vyn, och den associerade utlösaren aktiveras. Eftersom utlösaren är en INSTEAD OF-utlösare kommer de underliggande tabellerna inte att ändras av programsatsen som aktiverar utlösaren. Utlösarna kan däremot användas för att utföra ändringar på de underliggande tabellerna.

Det finns en sak du bör tänka på när du skapar en utlösare i en tabell med en INTEGER PRIMARY KEY-kolumn. Om en BEFORE-utlösare ändrar INTEGER PRIMARY KEY-kolumnen för en rad som uppdateras av programsatsen som aktiverar utlösaren, uppdateras den inte. Du kan komma runt problemet genom att skapa tabellen med en PRIMARY KEY-kolumn istället för en INTEGER PRIMARY KEY-kolumn.

En utlösare kan tas bort med hjälp av programsatsen DROP TRIGGER. När en tabell eller vy tas bort, kommer alla utlösare som är associerade med tabellen eller vyn också att tas bort.

Funktionen RAISE()

Den särskilda SQL-funktionen RAISE() kan användas i en trigger-step-programsats i en utlösare. Den här funktionen har följande syntax:

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

Om en av de första tre formerna anropas vid en utlösaråtgärd, utförs den specificerade ON CONFLICT-processåtgärden (ABORT, FAIL eller ROLLBACK) och den aktuella programsatsen avslutas. ROLLBACK betraktas som ett körningsfel, vilket medför att den SQLStatement-instans vars execute()-metod utfördes genererar en (SQLErrorEvent.ERROR)-felhändelse. Det SQLError-objekt som finns i det skickade händelseobjektets felegenskap, har details-egenskapen inställd på det error-message som finns angiven i RAISE()-funktionen.

När RAISE(IGNORE) anropas, överges resten av den aktuella utlösaren, programsatsen som aktiverade utlösaren och alla efterföljande utlösare. Inga databasändringar rullas tillbaka. Om programsatsen som aktiverar utlösaren själv är en del av en utlösare, kommer detta utlösarprogram att återuppta åtgärden i början av nästa steg. Mer information om konfliktlösningsalgoritmer finns i avsnittet ON CONFLICT (konfliktalgoritmer).

DROP TRIGGER

Programsatsen DROP TRIGGER tar bort en utlösare som har skapats med CREATE TRIGGER.

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

Utlösaren raderas från databasen. Observera att utlösarna släpps automatiskt när deras associerade tabeller släpps.

COLLATE

Satsen COLLATE används i SELECT-, CREATE TABLE- och CREATE INDEX-programsatserna för att specificera den jämförelsealgoritm som ska användas vid en jämförelse eller sortering.

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

Standardkollationstypen för kolumner är BINARY. Om BINARY används med värden från lagringsklassen TEXT, jämförs de minnesbyte som representerar värdet, oavsett aktuell textkodning.

Kollationen NOCASE gäller endast värden i lagringsklassen TEXT. Om NOCASE används, är jämförelsen inte skiftlägeskänslig.

Ingen kollationssekvens används för lagringsklasser av typen NULL, BLOB, INTEGER eller REAL.

För att använda en annan kollationstyp än BINARY med en kolumn, måste COLLATE anges som en del av kolumndefinitionen i CREATE TABLE. När två TEXT-värden jämförs, används en kollationssekvens för att bestämma resultatet av jämförelsen enligt följande regler:

EXPLAIN

Kommandomodifieraren EXPLAIN är ett tillägg som inte ingår i SQL-standarden.

sql-statement  ::=  EXPLAIN sql-statement

Om nyckelordet EXPLAIN står före andra SQL-programsatser körs inte själva kommandot. Däremot ger resultatet sekvensen av de virtuella maskininstruktioner som skulle ha använts för att utföra kommandot, om nyckelordet EXPLAIN inte hade funnits med. Funktionen EXPLAIN är en avancerad funktion som underlättar för utvecklare att ändra SQL-programsatser i ett försök att optimera prestanda eller felsöka en programsats som inte verkar fungera ordentligt.

ON CONFLICT (konfliktalgoritmer)

Satsen ON CONFLICT är inte ett separat SQL-kommando. Det är en sats som inte ingår i standarden och som kan förekomma i andra SQL-kommandon.

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

Den första formen av ON CONFLICT-satsen med nyckelorden ON CONFLICT används i en CREATE TABLE-programsats. För programsatsen INSERT eller UPDATE används den andra formen med ON CONFLICT som ersätts av OR för att få en mer naturlig syntax. Till exempel blir programsatsen INSERT OR IGNORE i stället för INSERT ON CONFLICT IGNORE. Även om nyckelorden är olika är båda satserna semantiskt ekvivalenta.

Satsen ON CONFLICT specificerar den algoritm som används för att lösa konflikter mellan begränsningar. De fem algoritmerna är ROLLBACK, ABORT, FAIL, IGNORE och REPLACE. Standardalgoritmen är ABORT. Här följer en förklaring av de fem konliktalgoritmerna:

ROLLBACK

När en konflikt mellan olika begränsningar inträffar sker en ROLLBACK direkt och den aktuella transaktionen slutförs. Kommandot avbryts och SQLStatement-instansen genererar en error-händelse. Om ingen transaktion är aktiv (annat än implicita transaktioner som skapas för varje kommando) fungerar denna algoritm på samma sätt som ABORT.

ABORT

När konflikt mellan olika begränsningar inträffar, tar kommandot tillbaka tidigare ändringar som det har utfört och SQLStatement-instansen genererar en error-händelse. Ingen ROLLBACK utförs, och ändringar från tidigare kommandon inom en transaktion bevaras. ABORT är standardbeteendet.

FAIL

När en konflikt mellan olika begränsningar inträffar, avbryts kommandot och SQLStatement-instansen genererar en error-händelse. Ändringar i databasen som programsatsen gjorde innan konflikten inträffade, bevaras och tas inte tillbaka. Om en UPDATE-programsats till exempel påträffar en konflikt på rad 100, bevaras de ändringar som gjordes på de första 99 raderna. Däremot försvinner de ändringar som har gjorts på rad 100 och framåt.

IGNORE

När en konflikt mellan olika begränsningar inträffar, ändras eller infogas inte den rad där konflikten inträffade. Förutom att den här raden ignoreras, fortsätter kommandot normalt. Andra rader före och efter raden som innehåller konfliken infogas eller uppdateras normalt. Inget fel returneras.

REPLACE

När en UNIQUE-konflikt mellan olika begränsningar inträffar, tas föregående rader som orsakade konflikten, innan infogning eller uppdatering av aktuell rad, bort. Följaktligen görs alltid infogning eller uppdatering och sedan fortsätter kommandot normalt. Inget fel returneras. Om en NOT NULL-konflikt inträffar, ersätts NULL-värdet med standardvärdet för den kolumnen. Om kolumnen inte har något standardvärde används ABORT-algoritmen. Om en CHECK-överträdelse inträffar, används algoritmen IGNORE. När den här konfliktlösningsstrategin tar bort rader för att tillgodose en begränsning, aktiveras inte raderingsutlösarna för dessa rader.

Den algoritm som anges i OR-satsen i en INSERT- eller UPDATE-programsats åsidosätter de algoritmer som anges med CREATE TABLE. Om ingen algoritm är specificerad i CREATE TABLE eller i den INSERT eller UPDATE som körs, används ABORT.

REINDEX

Kommandot REINDEX används för att ta bort och regenerera ett eller flera index. Det här kommandot kan användas när definitionen av en kollationssekvens har ändrats.

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

Med den första formen återskapas alla index i relevanta databaser som använder den namngivna kollationssekvensen. I den andra formen, när en table-name specificeras, återskapas alla index som är associerade med tabellen. Om ett index-name är givet, återskapas och raderas endast specificerat index.

COMMENTS

Kommentarer är inte SQL-kommandon, men de kan förekomma i SQL-databasfrågor. De behandlas som blanktecken i körningsbiblioteket. De kan börja var som helst där det kan finnas ett blanktecken, inklusive inuti uttryck som sträcker sig över flera rader.

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

En enkelradskommentar anges med två tankstreck. En enkelradskommentar sträcker sig endast till slutet på den aktuella raden.

Blockkommentarer kan sträcka sig över flera rader eller vara inbäddade i en enkelrad. Om det inte finns en avslutande avgränsare, fortsätter blockkommentarer till slutet av inmatningen. Detta hanteras inte som ett syntaktiskt fel. En ny SQL-programsats kan börja på en rad efter att en blockkommentar slutar. Blockkommentarer kan bäddas in var som helst där det kan finnas ett blanktecken, inklusive inuti uttryck och i mitten av en annan SQL-programsats. Blockkommentarer kan inte kapslas i varandra. Enkelradskommentarer inuti en blockkommentar ignoreras.

EXPRESSIONS

Uttryck är underkommandon i andra SQL-block. Här nedan beskrivs giltig syntax för uttryck inom en SQL-programsats:

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

Ett uttryck är en kombination av värden och operatorer som kan evalueras till ett enda värde. Uttryck kan delas in i två typer beroende på om de blir ett booleskt (sant eller falskt) värde eller om de blir ett icke booleskt värde.

I många situationer måste uttrycket kunna evalueras till ett booleskt värde, till exempel i en WHERE- eller HAVING-sats, i ON-uttrycket i en JOIN-sats och i ett CHECK-uttryck. Följande typer av uttryck uppfyller detta krav:

• ISNULL

• NOTNULL

• IN ()

• EXISTS ()

• LIKE

• GLOB

• Vissa funktioner

• Vissa operatorer (specifika jämförelseoperatorer)

Literala värden

Ett literalt numeriskt värde skrivs som en heltalssiffra eller ett flyttal. Exponentformer stöds. Tecknet . (punkt) används alltid som decimaltecken.

En strängliteral indikeras genom att strängen står inom enkla citattecken ('). Om du vill använda ett enkelt citattecken i en sträng, sätter du två enkla citattecken i rad enligt följande:''.

Ett booleskt literalt värde indikeras av true eller false. Literala booleska värden används med kolumndatatypen Boolean.

En BLOB-literal är en strängliteral som innehåller hexadecimala data och föregås av tecknet x eller X, såsom i X'53514697465'.

Ett literalt värde kan även vara token NULL.

Kolumnnamn

Ett kolumnnamn kan vara något av namnen som definierades i programsatsen CREATE TABLE eller i en av följande särskilda identifierare: ROWID, OID eller _ROWID_. Dessa identifierare beskriver den unika heltalsslumpnyckeln (radnyckeln) som är kopplad till varje rad i varje tabell. De särskilda identifierarna refererar enbart till radnyckeln om programsatsen CREATE TABLE inte definierar en befintlig kolumn med samma namn. Radnycklar fungerar som skrivskyddade kolumner. En radnyckel kan användas var som helst där en vanlig kolumn kan användas, förutom att du inte kan ändra värdet för radnyckeln med UPDATE eller INSERT. SELECT * FROM "tabell" inkluderar inte radnyckeln i resultatet.

SELECT

Programsatsen SELECT kan förekomma i ett uttryck som antingen den högra operanden för operatorn IN eller som ett skalärvärde (ett entydigt resultatvärde), eller som en operand för operatorn EXISTS. När den används som ett skalärvärde eller som operand för en IN-operator, kan SELECT endast ha en enda kolumn i resultatet. En sammansatt SELECT-programsats (kopplad med nyckelord som UNION eller EXCEPT) är tillåten. Med EXISTS-operatorn, ignoreras kolumner i resultatet för SELECT, och uttrycket returnerar TRUE om det finns en eller flera rader eller FALSE om resultatmängden är tom. Om ingen term i SELECT-uttrycket refererar till värdet i frågan, kommer uttrycket att evalueras en gång innan annan bearbetning utförs och resultatet kan användas flera gånger vid behov. Om SELECT-uttrycket innehåller variabler från den yttre frågan (kallas även korrelerad underfråga) kommer SELECT att evalueras varje gång det behövs.

När SELECT är den högra operanden för operatorn IN, returnerar operatorn IN TRUE om resultatet från den vänstra operanden är detsamma som något av värdena i SELECT-programsatsens resultat. Operatorn IN kan föregås av nyckelordet NOT för att invertera testet.

När en SELECT förekommer i ett uttryck utan att vara den högra operanden för operatorn IN, blir den första raden i resultatet av SELECT det värde som används i uttrycket. Om SELECT ger mer än en resultatrad, kommer alla rader efter den första att ignoreras. Om SELECT inte ger några rader är värdet för SELECT lika med NULL.

CAST

Uttrycket CAST konverterar värdets datatyp till en given datatyp. Datatypen kan vara vilket icke-tomt namn som helst som är giltigt för typen i en kolumndefinition i en CREATE TABLE-programsats. Se Datatyper som stöds.

Övriga uttryckselement

Här beskrivs andra SQL-element som kan användas i uttryck:

• Inbyggda funktioner: Sammanställningsfunktioner, Skalärfunktioner och Formateringsfunktioner för datum och tid

• Operatorer

• Parametrar

Sammanställningsfunktioner

Sammanställningsfunktioner utför åtgärder på värden från flera rader. Dessa funktioner används primärt i SELECT-programsatser i kombination med GROUP BY.

I alla de föregående sammanställningsfunktionerna som tar ett argument, kan det argumentet föregås av nyckelordet DISTINCT. I så fall dupliceras element som är filtrerade innan de skickas till sammanställningsfunktionen. Funktionen anropar till exempel COUNT(DISTINCT x) som returnerar antal distinkta värden i kolumn X istället för totalt antal icke-NULL-värden i kolumn x.

Skalärfunktioner

Skalärfunktioner arbetar med värden från en rad i taget.

Formateringsfunktioner för datum och tid

Formateringsfunktioner för datum och tid är en grupp skalärfunktioner som används för att skapa formaterade datum- och tidsvärden. Observera att dessa funktioner bearbetar och returnerar strängar och talvärden. Dessa funktioner är inte tänkta att användas med datatypen DATE. Om du använder dessa funktioner på data i en kolumn vars datatyp är DATE, kommer de inte att ge förväntat resultat.

Tidsformat

Tecknet T i dessa format är det literala tecknet "T" som avgränsar datum och tid. Format som endast inkluderar en tid får datumet 2001-01-01.

Modifierare

Vanliga operatorer

Följande binära operatorer tillåts i ett SQL-block och visas sorterade från högsta till lägsta prioritetsordning:

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

Unära prefixoperatorer som stöds är:

 !    ~    NOT

Operatorn COLLATE motsvarar en unär postfix-operator. Operatorn COLLATE har prioritet framför alla andra operatorer. Den binder alltid hårdare än andra unära prefix-operatorer eller binära operatorer.

Observera att det finns två varianter av likhetsoperatorer. Likheten kan vara antingen = eller ==. De operatorer som uttrycker skillnad kan vara antingen != eller <>.

Operatorn || ger strängsammanfogning —. Den sammanfogar de två operandsträngarna.

Operatorn % ger resten vid division mellan vänster och höger operand (modulo).

Resultatet av binära operatorer är ett numeriskt värde förutom för sammanfogningsoperatorn || som ger ett strängresultat.

SQL-operatorer

LIKE

Operatorn LIKE gör en mönstermatchningsjämförelse.

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

Operanden till höger om LIKE innehåller mönstret och operanden till vänster innehåller strängen som ska matchas mot mönstret. Ett procenttecken (%) i mönstret fungerar som jokertecken och det matchar sekvenser med noll eller flera tecken i strängen. Ett understreck (_) i mönstret matchar ett tecken i strängen. Andra tecken matchar sig själva eller motsvarande små/stora bokstäver, det vill säga matchningen är inte skiftlägeskänslig. (Obs! Databasmotorn hanterar bara skillnaden mellan gemener och versaler för 7-bitars latinska tecken. Därför är operatorn LIKE skiftlägeskänslig för 8-bitars iso8859-tecken och UTF-8-tecken. Till exempel är uttrycket 'a' LIKE 'A' TRUE, men 'æ' LIKE 'Æ' är FALSE). Skiftlägeskänsligheten för latinska tecken kan ändras med egenskapen SQLConnection.caseSensitiveLike.

Om den valfria satsen ESCAPE finns med, måste uttrycket som följer nyckelordet ESCAPE evalueras till en sträng som består av ett tecken. Det här tecknet kan användas i LIKE-mönstret för att matcha literala procent- eller understrecktecken. Escape-tecknet följt av en procentsymbol, ett understreck eller sig själv matchar en literal procentsymbol, understreck eller escape-tecken i strängen.

GLOB

Operatorn GLOB påminner om LIKE men använder Unix-syntaxen för jokertecken. Till skillnad från LIKE är operatorn GLOB skiftlägeskänslig.

IN

Operatorn IN beräknar om dess vänstra operand har samma värde som ett av värdena i den högra operanden (en mängd värden inom parentes).

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

Den högra operanden kan vara en uppsättning av kommaseparerade literala värden, eller så kan den vara ett resultat av en SELECT-programsats. Se även SELECT-programsatser i uttryck för en förklaring och begränsningar av hur du kan använda SELECT som högeroperand för operatorn IN.

BETWEEN...AND

Operatorn BETWEEN...AND är ekvivalent med användning av två uttryck med operatorerna >= och <=. Till exempel är uttrycket x BETWEEN y AND z lika med x >= y AND x <= z.

NOT

Operatorn NOT är negationsoperatorn i SQL. Operatorerna GLOB, LIKE och IN kan föregås av nyckelordet NOT för att invertera logiken (med andra ord kontrollera att värdet inte matchar det angivna mönstret).