SQLConnection  - AS3

Anger om automatisk komprimering var aktiverad när den aktuella databasen ursprungligen skapades (värdet som angavs för parametern autoCompact i open()- eller openAsync()-anropet som skapade databasen). Om egenskapen är true, tas oanvänt utrymme automatiskt bort från databasfilen efter varje skrivåtgärd, vilket gör databasfilerna mindre. Om egenskapen är false lämnas utrymmet från borttagna data oanvänt i databasfilen och återanvänds vid behov. Även om autoCompact är false, kan du tvinga databasen att återvinna oanvänt utrymme genom att anropa compact()-metoden.

Om egenskapen connected är false är den här egenskapen inställd på false.

Relaterade API-element

Ger åtkomst till anslutningens cache-storlek som representerar det högsta antalet databasdisksidor som hålls i minnet åt gången. Varje sida använder cirka 1,5 KB minne (beroende på vilket värde som har angetts för parametern pageSize i open()- eller openAsync()-metodanropet som skapade databasen). Standardvärdet för cache-storleken är 2 000. Om ett program kör UPDATE- eller DELETE-åtgärder som ändrar många rader i en databas, kan ökad cache-storlek ge högre hastighet till priset av ökad minnesförbrukning.

Relaterade API-element

Anger hur kolumnnamn rapporteras i SELECT-satsresultatet.

Konstanterna i SQLColumnNameStyle-klassen representerar möjliga värden för egenskapen:

• SQLColumnNameStyle.LONG anger att kolumnnamnen returneras i formatet [table-name]_[column-name].
• SQLColumnNameStyle.SHORT anger att kolumnnamnen får formatet [kolumn-namn]. Om det finns flera kolumner med samma namn, läggs endast en egenskap med detta namn till i resultatobjektet.
• SQLColumnNameStyle.DEFAULT är standardvärdet. När det här värdet används formateras resultatkolumnnamnen efter antalet tabeller i SELECT-satsen som har liknande kolumnnamn. Om SELECT-satsen bara innehåller en tabell används det korta namnformatet [column-name], och om SELECT-satsen innehåller flera tabeller som har förenats, och det uppstår en namnkrock på grund av två identiska kolumnnamn, används det långa namnformatet [table-name]_[column-name] för de kolumner som har identiska namn.

Relaterade API-element

Anger om SQLConnection-instansen har en öppen anslutning till en databasfil.

Relaterade API-element

Anger om anslutningen för närvarande används i en transaktion.

Relaterade API-element

Anger om SQLConnection-klassen stöds på den aktuella plattformen eller inte.

Radidentifierare av den senaste raden som har skapats av en SQL INSERT-sats. En radidentifierare används för att unikt identifiera en rad i tabellen inom databasen. Värdet genereras ofta av databasen.

Värdet är noll om ingen databas är ansluten eller ingen INSERT-sats har körts.

Radidentifieraren för en enkel SQL INSERT-satsåtgärd kan tillhandahållas genom lastInsertRowID-egenskapen i SQLResult-objektet som returneras av SQLStatement-objektets getResult()-metod (när den anropas efter att SQLStatement skickar en result-händelse).

Mer information om primära nycklar och genererade radidentifierare finns i avsnitten om ”CREATE TABLE” och ”Uttryck” i bilagan ”SQL-stöd i lokala databaser”.

Relaterade API-element

Anger databasens sidstorlek (i byte) som angavs när den aktuella databasen ursprungligen skapades (värdet som angavs för parametern pageSize i open()- eller openAsync()-anropet som skapade databasen).

Om egenskapen connected är false är egenskapens värde 0.

En databas sidstorlek kan ändras (med metoden open() eller openAsync()) tills första tabellen skapas i databasen.

Relaterade API-element

Innehåller det totala antalet dataändringar som har utförts sedan anslutningen till databasen upprättades. Förutom att spåra ändringar som har gjorts med INSERT-, DELETE- och UPDATE-satser inkluderar värdet ändringar som har orsakats av utlösare.

När databasanslutningen stängs återställs värdet till 0. När SQLConnection-instansen inte är ansluten till en databas är värdet 0.

Relaterade API-element

Skapar en SQLConnection-instans.

Registrerar ett händelseavlyssnarobjekt för ett EventDispatcher-objekt så att avlyssnaren får meddelanden om händelser. Du kan registrera händelseavlyssnare på alla noder i visningslistan efter en särskild typ av händelse, fas och prioritet.

När du har registrerat en händelseavlyssnare går det inte att ändra dess prioritet genom ytterligare anrop till addEventListener(). För att kunna ändra avlyssnarens prioritet måste du först anropa removeListener(). Sedan går det att registrera avlyssnaren på nytt med den nya prioritetsnivån.

Kom ihåg att när avlyssnaren har registrerats så skapar anrop till addEventListener() med annan type eller useCapture-värde en separat avlyssnarregistrering. Om du till exempel först registrerar en avlyssnare med useCapture inställt på true, avlyssnar den bara under hämtningsfasen. Om du anropar addEventListener() igen med samma avlyssningsobjekt men med useCapture inställt på false, får du två separata avlyssnare: en som avlyssnar under hämtningsfasen och en som avlyssnar under både mål- och bubblingsfasen.

Det går inte att registrera en händelseavlyssnare endast för målfasen eller bubblingsfasen. De faserna är sammankopplade vid registreringen eftersom bubblande bara tillämpas på de som är överordnade målnoden.

Om du inte längre behöver en händelseavlyssnare tar du bort den genom att anropa removeEventListener(). Annars finns risk för minnesproblem. Händelseavlyssnare tas inte automatiskt bort från minnet, eftersom skräpinsamlaren inte tar bort avlyssnaren så länge det skickande objektet finns (om inte parametern useWeakReference är true).

Kopiering av en EventDispatcher-instans innebär inte att de händelseavlyssnare som är kopplade till den kopieras. (Om en nod som du nyss skapat behöver en händelseavlyssnare måste du koppla avlyssnaren efter att du skapat noden.) Om du däremot flyttar en EventDispatcher-instans flyttas den kopplade händelseavlyssnaren med.

Om händelseavlyssnaren är registrerad på en nod samtidigt som en händelse bearbetas på den noden aktiveras inte händelseavlyssnaren under den aktuella fasen, men den kan aktiveras under en senare fas i händelseflödet, t.ex. bubblingsfasen.

Om en händelseavlyssnare tas bort från en nod samtidigt som en händelse bearbetas på den noden, aktiveras den ändå av de aktuella åtgärderna. När händelseavlyssnaren tagits bort anropas den aldrig mer (om den inte registreras på nytt för framtida bearbetning).

Parametrar

function(evt:Event):void

Samlar in statistik om databasindex och lagrar dem i databasen. Statistiken kan sedan användas av frågeoptimeraren (den del av databasmotorn som avgör vilket satskörningssätt som är mest effektivt). Statistiken hjälper frågeoptimeraren att göra bättre val i fråga om vilket eller vilka index som ska användas vid körningen av en viss fråga.

Om en databas har definierade indexvärden, men analyze()-metoden inte har anropats, används ändå indexvärdena i körningen för att köra satser. Däremot kanske inte det mest effektiva indexvärdet för en specifik fråga används i körningen om den extra statistikinformationen som erhålls av analyze()-metoden saknas.

När tabelldata ändras (till följd av INSERT-, UPDATE- eller DELETE-satser) ändras även indexvärden som är associerade med tabellen. Statistisk information som har genererats av analyze() uppdateras inte automatiskt. Därför kan det vara fördelaktigt att anropa metoden analyze() på nytt efter många dataändringar. Hur stor fördelen med att anropa analyze() på nytt blir, beror dock på flera faktorer, t.ex. antalet definierade indexvärden för en tabell, relationen mellan antalet ändrade rader och det totala antalet rader i tabellen, och variationsskillnaden mellan tabellens indexerade data och hur stora dataändringar som har gjorts.

Parametern resourceName anger om åtgärden ska utföras på indexvärden för alla bifogade databaser, en viss databas eller en viss tabell.

Varje gång den här metoden anropas tas alla statistiska data som har skapats tidigare bort, och återskapas för den databas eller tabell som anges i parametern resourceName (eller för alla tabeller i alla anslutna databaser om resourceName är null). Den här metoden kan anropas när som helst när databasanslutningen är öppen. Åtgärden analyze() och dess statistiska data ingår inte i transaktionen, men det är bättre att inte anropa analyze() under en pågående databastransaktion (egenskapen inTransaction är true). Skälet är att ändringar i data, tabellscheman eller indexvärden som har körts i transaktionen, men ännu inte har verkställts, inte kommer att tas med i beräkningen i analyze()-anropet. analyze()-data kommer därför att vara inaktuella så snart transaktionen har verkställts.

Du kan ta bort statistiska data som har skapats med analyze()-metoden med hjälp av deanalyze()-metoden.

Parametrar

Relaterade API-element

Lägger till ytterligare en databas till SQLConnection-instansen och ger den nya databasen det angivna namnet. Genom att bifoga en databas kan du använda databasen i SQL-satser som körs mot SQLConnection-instansen.

Ett fel inträffar om en databas med det angivna namnet redan har bifogats när attach() anropas. Samma databas kan dock bifogas flera gånger genom att unika namn används. Endast tio databaser kan bifogas till en enstaka SQLConnection-instans.

Samma SQL-satser kan köras både på en databas som har anslutits med hjälp av attach() och på huvuddatabasen (databasen som har anslutits med open() eller openAsync()). En SQL-sats har åtkomst till tabellerna i alla databaser som har bifogats till satsens associerade SQLConnection-instans, inklusive åtkomst till tabeller från flera databaser i en enstaka sats. Körningen löser tabellnamn i en sats genom att söka igenom SQLConnection-instansens databaser i den ordning som databaserna har bifogats, och börjar då med den databas som har anslutits med metoden open() eller openAsync(). Använd databasnamnet (som anges i attach()-metodens parameter name) i satsen för att tydligt ange ett tabellnamn.

Om du vill ta bort en databas som har bifogats med attach()-metoden använder du detach()-metoden. När en SQLConnection stängs (genom anrop till metoden close()) frigörs alla bifogade databaser.

Den bifogade databasen använder samma körningsläge (synkront eller asynkront) som huvuddatabasen, beroende på om huvuddatabasen har anslutits med metoden open() eller metoden openAsync().

Parametrar

Relaterade API-element

Startar en transaktion där alla SQL-satser som körs mot anslutningens databas eller databaser grupperas.

Som standard körs varje SQL-sats inom sin egen transaktion, och transaktionen slutar när satskörningen har slutförts eller misslyckats. En transaktion som skapas med metoden begin() ger upphov till en ny manuell transaktion. Därefter körs alla SQL-satser mot SQLConnection-instansen inom transaktionen, och alla åtgärder eller ändringar som utförs av satsen kan verkställas (permanentas) eller backas ut (ångras) i grupp.

Om du vill avsluta en transaktion anropar du någon av metoderna commit() eller rollback(), beroende på om ändringarna som transaktionernas satser har utfört ska permanentas eller tas bort.

Kapslade anrop till begin() ignoreras. Du kan skapa lagringspunkter som fungerar som bokmärken i en transaktion genom att anropa metoden setSavepoint(). Du kan sedan delvis verkställa eller återställa SQL-satser genom att anropa metoden releaseSavepoint() eller rollbackToSavepoint(). Om du startar en transaktion genom att anropa begin(), kommer dock inte ändringarna att verkställas permanent i databasen förrän metoden commit() anropas.

Om databasanslutningen stängs medan en transaktion är öppen, ångras transaktionen automatiskt. (Obs! när det gäller AIR 1.1 och tidigare versioner sparas en öppen transaktion automatiskt när en anslutning stängs.)

En transaktion är inte begränsad till satskörningar i en enda databas utan kan omfatta satser som körs på flera bifogade databaser.

Parametrar

Relaterade API-element

package
{
    import flash.data.SQLConnection;
    import flash.data.SQLResult;
    import flash.data.SQLStatement;
    import flash.display.Sprite;
    import flash.events.SQLErrorEvent;
    import flash.events.SQLEvent;
    import flash.filesystem.File;
    
    public class MultiInsertTransactionExample extends Sprite
    {
        private var conn:SQLConnection;
        private var insertEmployee:SQLStatement;
        private var insertPhoneNumber:SQLStatement;
        
        public function MultiInsertTransactionExample():void
        {
            // define where to find the database file
            var appStorage:File = File.applicationStorageDirectory;
            var dbFile:File = appStorage.resolvePath("ExampleDatabase.db");
            
            // open the database connection
            conn = new SQLConnection();
            conn.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            conn.addEventListener(SQLEvent.OPEN, openHandler);
            conn.openAsync(dbFile);
        }
        
        // Called when the database is connected
        private function openHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.OPEN, openHandler);
            
            // start a transaction
            conn.addEventListener(SQLEvent.BEGIN, beginHandler);
            conn.begin();
        }
        
        // Called when the transaction begins
        private function beginHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.BEGIN, beginHandler);
            
            // create and execute the first SQL statement:
            // insert an employee record
            insertEmployee = new SQLStatement();
            insertEmployee.sqlConnection = conn;
            insertEmployee.text = 
                "INSERT INTO employees (lastName, firstName, email) " + 
                "VALUES (:lastName, :firstName, :email, :birthday)";
            insertEmployee.parameters[":lastName"] = "Smith";
            insertEmployee.parameters[":firstName"] = "Bob";
            insertEmployee.parameters[":email"] = "bsmith@example.com";
            insertEmployee.parameters[":birthday"] = new Date(1971, 8, 12);
            
            insertEmployee.addEventListener(SQLEvent.RESULT, insertEmployeeHandler);
            insertEmployee.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            insertEmployee.execute();
        }
        
        // Called after the employee record is inserted
        private function insertEmployeeHandler(event:SQLEvent):void
        {
            insertEmployee.removeEventListener(SQLEvent.RESULT, insertEmployeeHandler);
            insertEmployee.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // Get the employee id of the newly created employee row
            var result:SQLResult = insertEmployee.getResult();
            var employeeId:Number = result.lastInsertRowID;
            
            // Add a phone number to the related phoneNumbers table
            insertPhoneNumber = new SQLStatement();
            insertPhoneNumber.sqlConnection = conn;
            insertPhoneNumber.text =
                "INSERT INTO phoneNumbers (employeeId, type, number) " +
                "VALUES (:employeeId, :type, :number)";
            insertPhoneNumber.parameters[":employeeId"] = employeeId;
            insertPhoneNumber.parameters[":type"] = "Home";
            insertPhoneNumber.parameters[":number"] = "(555) 555-1234";
            
            insertPhoneNumber.addEventListener(SQLEvent.RESULT, insertPhoneNumberHandler);
            insertPhoneNumber.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            insertPhoneNumber.execute();
        }
        
        // Called after the phone number record is inserted
        private function insertPhoneNumberHandler(event:SQLEvent):void
        {
            insertPhoneNumber.removeEventListener(SQLEvent.RESULT, insertPhoneNumberHandler);
            insertPhoneNumber.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // No errors so far, so commit the transaction
            conn.addEventListener(SQLEvent.COMMIT, commitHandler);
            conn.commit();
        }
        
        // Called after the transaction is committed
        private function commitHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.COMMIT, commitHandler);
            
            trace("Transaction complete");
        }
        
        // Called whenever an error occurs
        private function errorHandler(event:SQLErrorEvent):void
        {
            // If a transaction is happening, roll it back
            if (conn.inTransaction)
            {
                conn.addEventListener(SQLEvent.ROLLBACK, rollbackHandler);
                conn.rollback();
            }
            
            trace(event.error.message);
            trace(event.error.details);
        }
        
        // Called when the transaction is rolled back
        private function rollbackHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.ROLLBACK, rollbackHandler);
            
            // add additional error handling, close the database, etc.
        }
    }
}

package
{
    import flash.data.SQLConnection;
    import flash.data.SQLResult;
    import flash.data.SQLStatement;
    import flash.display.Sprite;
    import flash.events.SQLErrorEvent;
    import flash.events.SQLEvent;
    import flash.filesystem.File;
    
    public class MultiDeleteTransactionExample extends Sprite
    {
        private var conn:SQLConnection;
        private var deleteEmployee:SQLStatement;
        private var deletePhoneNumbers:SQLStatement;
        
        private var employeeIdToDelete:Number = 25;
        
        public function MultiDeleteTransactionExample():void
        {
            // define where to find the database file
            var appStorage:File = File.applicationStorageDirectory;
            var dbFile:File = appStorage.resolvePath("ExampleDatabase.db");
            
            // open the database connection
            conn = new SQLConnection();
            conn.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            conn.addEventListener(SQLEvent.OPEN, openHandler);
            conn.openAsync(dbFile);
        }
        
        // Called when the database is connected
        private function openHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.OPEN, openHandler);
            
            // start a transaction
            conn.addEventListener(SQLEvent.BEGIN, beginHandler);
            conn.begin();
        }
        
        // Called when the transaction begins
        private function beginHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.BEGIN, beginHandler);
            
            // Create and execute the first SQL statement:
            // Delete an employee's phone number records
            deletePhoneNumbers = new SQLStatement();
            deletePhoneNumbers.sqlConnection = conn;
            deletePhoneNumbers.text =
                "DELETE FROM phoneNumbers " +
                "WHERE employeeId = :employeeId";
            deletePhoneNumbers.parameters[":employeeId"] = employeeIdToDelete;
            
            deletePhoneNumbers.addEventListener(SQLEvent.RESULT, deletePhoneNumbersHandler);
            deletePhoneNumbers.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deletePhoneNumbers.execute();
        }
        
        // Called after the phone number records are deleted
        private function deletePhoneNumbersHandler(event:SQLEvent):void
        {
            deletePhoneNumbers.removeEventListener(SQLEvent.RESULT, deletePhoneNumbersHandler);
            deletePhoneNumbers.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deleteEmployee = new SQLStatement();
            deleteEmployee.sqlConnection = conn;
            deleteEmployee.text = 
                "DELETE FROM employees " + 
                "WHERE employeeId = :employeeId";
            deleteEmployee.parameters[":employeeId"] = employeeIdToDelete;
            
            deleteEmployee.addEventListener(SQLEvent.RESULT, deleteEmployeeHandler);
            deleteEmployee.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deleteEmployee.execute();
        }
        
        // Called after the employee record is deleted
        private function deleteEmployeeHandler(event:SQLEvent):void
        {
            deleteEmployee.removeEventListener(SQLEvent.RESULT, deleteEmployeeHandler);
            deleteEmployee.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // No errors so far, so commit the transaction
            conn.addEventListener(SQLEvent.COMMIT, commitHandler);
            conn.commit();
        }
        
        // Called after the transaction is committed
        private function commitHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.COMMIT, commitHandler);
            
            trace("Transaction complete");
        }
        
        // Called whenever an error occurs
        private function errorHandler(event:SQLErrorEvent):void
        {
            // If a transaction is happening, roll it back
            if (conn.inTransaction)
            {
                conn.addEventListener(SQLEvent.ROLLBACK, rollbackHandler);
                conn.rollback();
            }
            
            trace(event.error.message);
            trace(event.error.details);
        }
        
        // Called when the transaction is rolled back
        private function rollbackHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.ROLLBACK, rollbackHandler);
            
            // add additional error handling, close the database, etc.
        }
    }
}

Avbryter alla SQL-satser som håller på att köras på databaser som är anslutna till SQLConnection-instansen. Den här metoden kan användas för att stoppa en fråga som har varit aktiv länge eller obesvarbara frågor.

Om satser håller på att köras när metoden cancel() anropas, avbryter den här metoden satsåtgärderna, och ofullständiga uppdateringar eller transaktioner backas ut. Om inga satser håller på att köras medför ett anrop till metoden inte någonting förutom att en öppen transaktion backas ut.

Parametrar

Relaterade API-element

Stänger den aktuella databasanslutningen. Eventuella bifogade databaser frigörs också.

Om en transaktion är öppen när close() anropas, återställs transaktionen. När en SQLConnection-instans skräpsamlas anropar körningen automatiskt close(), inklusive om ett AIR-program stängs medan en SQLConnection fortfarande är ansluten till en databas.

Parametrar

Verkställer en befintlig transaktion och permanentar därmed databasåtgärderna som transaktionssatserna har utfört.

Du kan skapa mellanliggande lagringspunkter som fungerar som bokmärken i en transaktion genom att anropa metoden setSavepoint(). Med lagringspunkter kan du verkställa delar av en transaktion genom att anropa metoden releaseSavepoint() eller återställa delar av en transaktion genom att anropa metoden rollbackToSavepoint(). Om en transaktion öppnas med metoden begin() sparas dock inte ändringarna permanent i databasen förrän hela transaktionen verkställs genom att metoden commit() anropas.

När en transaktion använder lagringspunkter kommer satser som återställs med metoden rollbackToSavepoint() inte att verkställas när hela transaktionen verkställs. Satser som verkställs med releaseSavepoint() eller vars lagringspunkter inte har frisläppts eller återställts verkställs i databasen.

Parametrar

Relaterade API-element

Återvinner allt oanvänt utrymme i databasen. När ett objekt (tabell, index eller utlösare) tas bort från databasen efterlämnar det en tom plats. Det här gör databasfilen större än nödvändigt men kan göra INSERT-åtgärder snabbare. Över tid kan INSERT- och DELETE-åtgärder medföra att databasfilstrukturen fragmenteras, vilket medför långsammare diskåtkomst till databasinnehållet. Den här metoden gör databasfilen mer kompakt, tar bort tomma sidor, justerar tabelldata så att de hänger samman och städar upp i databasfilstrukturen.

Åtgärden compact() kan inte utföras på en bifogad databasfil utan endast på huvuddatabasfilen (originalet) som har öppnats med SQLConnection-instansen. Den här åtgärden misslyckas om en aktiv transaktion pågår, och påverkar inte in-memory-databaser.

Parametrar

Tar bort all statistisk information som har skapats av ett anrop till analyze()-metoden.

Eftersom statistiken som har genererats av analyze()-metoden upptar plats i en databas kan du anropa deanalyze() och därmed återvinna utrymmet, till exempel efter att du har tagit bort flera index eller tabeller.

Den här åtgärden ingår inte i någon aktiv transaktion.

Parametrar

Relaterade API-element

Frigör en databas som tidigare har bifogats till SQLConnection-instansen med hjälp av attach()-metoden. Det går att bifoga samma databas flera gånger genom att använda olika namn. Om en filanslutning frigörs förblir de övriga intakta. En databas kan inte frigöras om anslutningen har en öppen transaktion (om egenskapen inTransaction är true).

Parametrar

Relaterade API-element

Ger åtkomst till resultatet av ett anrop till metoden loadSchema(). Metoden getSchemaResult() fungerar som en resultatkö enligt principen först-in-först-ut. Varje gång metoden loadSchema() har slutförts (varje gång schema-händelsen skickas i asynkront körningsläge), läggs ett nytt SQLSchemaResult-objekt till i kön. Varje gång metoden getSchemaResult() anropas returneras det tidigaste resultatet (det som först lades till i kön) och tas bort från kön. När det inte återstår fler objekt i kön returnerar getSchemaResult() null.

När databasanslutningen har stängts returnerar metoden null.

Relaterade API-element

Läser in schemainformation från den anslutna databasen eller eventuella bifogade databaser. Schemat visar strukturen för databasens tabeller, kolumner, indexvärden och utlösare.

Använd metoden SQLConnection.getSchemaResult() för att få åtkomst till det inlästa schemat.

I asynkront körningsläge skickas en schema-händelse om åtgärden fungerar och en error-händelse om åtgärden misslyckas.

Kombinationen av parametervärdena type och name avgör vilken typ av schemadata som genereras av metoden loadSchema() och därmed värdena på egenskaperna i de genererade SQLSchemaResult-instanserna. Följande tabell visar en lista över de giltiga type- och name-paren och de schemadata som genereras som resultat:

Om argumentkombinationen typ och namn inte motsvarar någon av de angivna kombinationerna skickas en error-händelse i asynkront körningsläge och ett undantag genereras i synkront körningsläge. Om till exempel typ-argumentet är SQLViewSchema och namn-argumentet är ett tabellnamn (snarare än ett vynamn) rapporteras ett fel som visar att databasen inte innehåller något objekt av den angivna typen med det angivna namnet.

Om databasen är tom (inte innehåller några tabeller, vyer, utlösare eller index) inträffar ett fel om metoden loadSchema() anropas.

Parametrar

Relaterade API-element

Öppnar en synkron anslutning till databasfilen på angiven plats i filsystemet, eller skapar och öppnar en ny databasfil på platsen, eller skapar och öppnar en in-memory-databas. Åtgärderna som skapar och öppnar databasen, liksom andra åtgärder som utförs med den här SQLConnection-instansen (inklusive satskörning och andra åtgärder som utförs med en SQLStatement-instans associerad med SQLConnection-instansen), utförs synkront när databasen öppnas med den här metoden. Om du vill utföra åtgärder asynkront upprättar du istället databasanslutningen med metoden openAsync().

När en databas väl har anslutits använder du en SQLStatement-instans för att köra SQL-kommandon. Åtgärder på databasnivå, som att till exempel inleda eller avsluta transaktioner eller läsa in schemainformation, utförs med SQLConnection-instansen.

En databas som ansluts med metoden open() får automatiskt databasnamnet "main". Det namnet kan användas för att kvalificera exakta tabellnamn i SQL-satser med formatet [databas-namn].[table-name].

Parametrar

Relaterade API-element

Öppnar en asynkron anslutning till databasfilen på angiven plats i filsystemet, eller skapar och öppnar en ny databasfil på platsen, eller skapar och öppnar en in-memory-databas. Åtgärderna att skapa och öppna databasen, liksom andra åtgärder som utförs med den här SQLConnection-instansen (inklusive satskörning och åtgärder som utförs med en SQLStatement-instans associerad med den här SQLConnection-instansen), utförs asynkront när databasen öppnas med den här metoden. Om du vill utföra åtgärder synkront upprättar du istället databasanslutningen med metoden open().

När en databas väl har anslutits använder du en SQLStatement-instans för att köra SQL-kommandon. Åtgärder på databasnivå, som att till exempel inleda eller avsluta transaktioner eller läsa in schemainformation, utförs med SQLConnection-instansen.

En databas som ansluts med metoden openAsync() får automatiskt databasnamnet "main". Det namnet kan användas för att kvalificera exakta tabellnamn i SQL-satser med formatet [databas-namn].[table-name].

Parametrar

Relaterade API-element

Ändrar krypteringsnyckeln för en krypterad databas. Den här metoden påverkar bara krypteringsnyckeln för huvuddatabasen (databasen som ansluts med metoden open() eller openAsync()). Du kan bara anropa reencrypt() för en databas som krypterades när den skapades. Om en databas har skapats som en krypterad databas, kan den inte bli okrypterad. En databas som skapas utan kryptering kan heller inte krypteras vid en senare tidpunkt.

Omkrypteringen körs i en egen transaktion. Om omkrypteringen avbryts, ångras transaktionen och krypteringsnyckeln ändras inte.

Parametrar

Relaterade API-element

Den här metoden genomför de SQL-åtgärder som begärts sedan den senaste lagringspunkten eller namngivna lagringspunkten, om ett namn har angetts.

Observera att inga ändringar sparas permanent i databasen förrän hela transaktionen har genomförts. Om transaktionen startas med metoden begin() måste du anropa metoden commit() för att genomföra hela transaktionen. Om transaktionen startas genom att du anropar setSavepoint() när inTransaction är false, kan du avsluta hela transaktionen antingen genom att anropa metoden commit() eller anropa releaseSavepoint() eller rollbackToSavepoint() för den första lagringspunkten i transaktionen.

Om koden anropar metoden rollback(), raderas alla ändringar i transaktionen permanent oavsett om releaseSavepoint() anropas innan transaktionen återställs.

Om metoden anropas utan parametrar (eller om null är angett för parametern name), verkställs alla databasändringar sedan den senaste, icke-namngivna lagringspunkten (den senaste lagringspunkten som skapats genom att anropa setSavepoint() utan parametern name). Om metoden setSavepoint() t.ex. har anropats tre gånger, ställs tre lagringspunkter in. Om releaseSavepoint() anropas vid den punkten verkställs SQL-åtgärderna som utförts sedan den tredje (senaste) lagringspunkten.

Om ett värde anges för parametern name verkställer den här metoden alla SQL-åtgärder som utförts sedan lagringspunkten med det angivna namnet. Om andra lagringspunkter har skapats efter den angivna lagringspunkten verkställs även åtgärderna som utförts efter dessa lagringspunkter.

När en lagringspunkt frisläpps eller återställs tas den lagringspunkten och alla senare lagringspunkter bort. Om koden kör ytterligare SQL-åtgärder efter att ett releaseSavepoint()- eller rollbackToSavepoint()-anrop har tagit bort en lagringspunkt, tillhör de åtgärderna den senaste av de kvarvarande lagringspunkterna. (De tillhör med andra ord den senast skapade lagringspunkten före den borttagna lagringspunkten.) Om inga lagringspunkter finns kvar tillhör åtgärderna huvudtransaktionen.

Parametrar

Relaterade API-element

Tar bort en avlyssnare från EventDispatcher-objektet. Ett anrop till den här metoden har ingen effekt om det inte finns någon matchande avlyssnare registrerad för EventDispatcher-objektet.

Parametrar

Ångrar en befintlig transaktion som har skapats med begin()-metoden, vilket innebär att alla ändringar som har utförts av någon SQL-sats i transaktionen tas bort.

Mellanliggande lagringspunkter kan markeras i en transaktion genom att anropa metoden setSavepoint(). Med lagringspunkter kan du verkställa delar av en transaktion genom att anropa metoden releaseSavepoint() eller återställa delar av en transaktion genom att anropa rollbackToSavepoint(). Om du anropar metoden rollback() kommer alla ändringar i en transaktion att tas bort permanent, oavsett om enskilda lagringspunkter har frisläppts (verkställts) innan transaktionen återställdes.

Parametrar

Relaterade API-element

Återställer alla SQL-åtgärder som begärts sedan den senaste lagringspunkten eller namngivna lagringspunkten, om ett namn har angetts.

Observera att om hela transaktionen verkställs genom att metoden commit() anropas, kommer eventuella ändringar i transaktionen som inte redan återställts med metoden rollbackToSavepoint() att sparas permanent i databasen. Dessutom, om du anropar metoden rollback() kommer alla ändringar att tas bort permanent, oavsett om enskilda lagringspunkter har frisläppts (verkställts) eller återställts innan transaktionen återställdes.

Om metoden anropas utan parametrar (eller om null är angett för parametern name), återställs alla databasändringar sedan den senaste, icke-namngivna lagringspunkten (det senaste anropet till setSavepoint() utan parametervärdet name).

Om ett värde anges för parametern name återställer den här metoden alla SQL-åtgärder som utförts sedan lagringspunkten med det angivna namnet. Om andra lagringspunkter har skapats efter den angivna lagringspunkten återställs även åtgärderna som utförts efter dessa lagringspunkter.

När en lagringspunkt frisläpps eller återställs tas den lagringspunkten och alla senare lagringspunkter bort. Om koden kör ytterligare SQL-åtgärder efter att ett releaseSavepoint()- eller rollbackToSavepoint()-anrop har tagit bort en lagringspunkt, tillhör de åtgärderna den senaste av de kvarvarande lagringspunkterna. (De tillhör med andra ord den senast skapade lagringspunkten före den borttagna lagringspunkten.) Om inga lagringspunkter finns kvar tillhör åtgärderna huvudtransaktionen.

Parametrar

Relaterade API-element

Skapar en lagringspunkt, som är som ett bokmärke i en databastransaktion. En lagringspunkt representerar en punkt inuti en transaktion. De SQL-åtgärder som utförts mellan lagringspunkterna kan verkställas eller återställas separat från andra åtgärder med metoderna releaseSavepoint() och rollbackToSavepoint(). På det sättet kan du behandla en uppsättning SQL-åtgärder som en kapslad transaktion med användning av en lagringspunkt.

Om en transaktion inte har öppnats (genom att metoden begin() anropas) startar en transaktion och en lagringspunkt skapas i början av transaktionen när metoden setSavepoint() anropas. Om en transaktion redan är öppen skapas en lagringspunkt i transaktionen när setSavepoint() anropas.

Observera att inga ändringar sparas permanent i databasen förrän hela transaktionen har genomförts. Om transaktionen startas med metoden begin() måste du anropa metoden commit() för att genomföra hela transaktionen. Om transaktionen startas genom att du anropar setSavepoint() när inTransaction är false, kan du avsluta hela transaktionen genom att anropa metoden commit(). Transaktionen avslutas även automatiskt när du anropar releaseSavepoint() eller rollbackToSavepoint() för lagringspunkten som startade transaktionen.

Du kan ge en lagringspunkt ett namn genom att ange ett värde för parametern name. Det gör att du kan återställa eller verkställa alla ändringar sedan den specifika lagringspunkten. En lagringspunkt utan namn skapas om ett namn inte anges (standardinställningen).

När en lagringspunkt frisläpps eller återställs tas den lagringspunkten och alla senare lagringspunkter bort. Om koden kör ytterligare SQL-åtgärder efter att ett releaseSavepoint()- eller rollbackToSavepoint()-anrop har tagit bort en lagringspunkt, tillhör de åtgärderna den senaste av de kvarvarande lagringspunkterna. (De tillhör med andra ord den senast skapade lagringspunkten före den borttagna lagringspunkten.) Om inga lagringspunkter finns kvar tillhör åtgärderna huvudtransaktionen.

Parametrar

Relaterade API-element

Skickas när en analyze()-åtgärd har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett attach()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett begin()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett cancel()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett close()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett commit()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett compact()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett deanalyze()-metodanrop har slutförts.

Relaterade API-element

Skickas när data ändras i någon av tabellerna i de anslutna databaserna till följd av ett SQL DELETE-kommando. Dataändringen kan vara ett direkt resultat av en DELETE-sats som körs genom en SQLStatement-instans eller ett indirekt resultat orsakat av en utlösare som har aktiverats som svar på en satskörning.

Relaterade API-element

Skickas när en åtgärd för ett detach()-metodanrop har slutförts.

Relaterade API-element

Skickas när någon av SQLConnection-objektets asynkrona åtgärder leder till ett fel. SQLErrorEvent-instansen som skickas som händelseobjekt har en error-egenskap som innehåller information om åtgärden som har misslyckats samt dess felorsak.

Skickas när data har ändrats i en tabell i någon av de anslutna databaserna till följd av ett SQL INSERT-kommando. Dataändringen kan vara ett direkt resultat av en INSERT-sats som körs genom en SQLStatement-instans eller ett indirekt resultat orsakat av en utlösare som har aktiverats som svar på en satskörning.

Relaterade API-element

Skickas när en åtgärd för ett openAsync()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett reencrypt()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett releaseSavepoint()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett rollback()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett rollbackToSavepoint()-metodanrop har slutförts.

Relaterade API-element

Skickas när en åtgärd för ett loadSchema()-metodanrop har slutförts och schemaresultaten är klara.

Relaterade API-element

Skickas när en åtgärd för ett setSavepoint()-metodanrop har slutförts.

Relaterade API-element

Skickas när data har ändrats i en tabell i någon av de anslutna databaserna till följd av ett SQL UPDATE-kommando. Dataändringen kan vara ett direkt resultat av en UPDATE-sats som körs igenom en SQLStatement-instans eller ett indirekt resultat orsakat av en utlösare som har aktiverats som svar på en satskörning.

Update-händelsen har följande egenskaper:

Relaterade API-element