SQLConnection  - AS3

Geeft aan of automatische compressie (auto-compacting) was ingeschakeld toen de huidige database werd gemaakt (de waarde die is opgegeven voor de parameter autoCompact in de aanroep van open() of openAsync() waarmee de database werd gemaakt). Als deze eigenschap true is, wordt ongebruikte ruimte na elke schrijfbewerking automatisch uit het databasebestand verwijderd, waardoor het databasebestand kleiner blijft. Als de eigenschap false is, blijft de ruimte die werd ingenomen door verwijderde gegevens in het databasebestand aanwezig en wordt deze ruimte zo nodig opnieuw gebruikt. Zelfs als autoCompact false is, kunt u de database dwingen ongebruikte ruimte vrij te geven door de methode compact() aan te roepen.

Als de eigenschap connected is ingesteld op false, wordt deze eigenschap ook ingesteld op false.

Verwante API-elementen

Biedt toegang tot de cachegrootte voor deze verbinding. Deze vertegenwoordigt het maximumaantal databaseschijfpagina's dat tegelijk in het geheugen kan worden opgeslagen. Elke pagina gebruikt circa 1,5 kB geheugen (afhankelijk van de waarde die is opgegeven voor de parameter pageSize tijdens de aanroep van de methode open() of openAsync() waarmee de database is gemaakt). De standaardcachegrootte is 2000. Als een toepassing UPDATE- of DELETE-bewerkingen uitvoert die een groot aantal rijen van een database wijzigen, kunt u de snelheid verhogen door de cache te vergroten, maar hierdoor wordt ook meer geheugen gebruikt.

Verwante API-elementen

Geeft aan hoe kolomnamen worden vermeld in het resultaat van een SELECT-instructie.

De constanten die zijn gedefinieerd in de klasse SQLColumnNameStyle vertegenwoordigen de mogelijke waarden voor deze eigenschap:

• SQLColumnNameStyle.LONG geeft aan dat kolomnamen worden geretourneerd in de notatie [tabelnaam]_[kolomnaam].
• SQLColumnNameStyle.SHORT geeft aan dat kolommen worden vermeld in de notatie [kolomnaam]. Als er meerdere kolommen met dezelfde naam zijn, wordt slechts één eigenschap met die naam toegevoegd aan het resultaatobject.
• SQLColumnNameStyle.DEFAULT is de standaardwaarde. Als deze waarde wordt gebruikt, wordt de notatie van de resulterende kolomnamen bepaald door het aantal tabellen in de SELECT-instructie dat dezelfde kolomnamen bevat. Als de instructie SELECT slechts één tabel bevat, wordt de korte notatie [kolomnaam] gebruikt. Als de instructie SELECT meerdere gekoppelde tabellen bevat en er naamconflicten ontstaan doordat twee kolomnamen identiek zijn, wordt de lange notatie [tabelnaam]_[kolomnaam] gebruikt voor kolommen met identieke namen.

Verwante API-elementen

Geeft aan of de SQLConnection-instantie een open verbinding met een databasebestand heeft.

Verwante API-elementen

Geeft aan of deze verbinding momenteel is betrokken bij een transactie.

Verwante API-elementen

Geeft aan of SQLConnection-klasse op het huidige platform wordt ondersteund of niet.

De laatste rij-id die is gemaakt door de SQL-instructie INSERT. Een rij-id wordt gebruikt als unieke identificatie voor een rij in een tabel in de database. De waarde wordt meestal gegenereerd door de database.

De waarde is nul als er geen database is verbonden of geen INSERT-instructie is uitgevoerd.

De rij-id voor één uitgevoerde SQL INSERT-instructie kan worden opgevraagd via de eigenschap lastInsertRowID van het SQLResult-object dat wordt geretourneerd door de methode getResult() van het SQLStatement-object (als deze wordt aangeroepen nadat de SQLStatement de gebeurtenis result verzendt).

Raadpleeg de secties "TABEL MAKEN" en "Expressies" in de bijlage "SQL-ondersteuning in lokale databases" voor meer informatie over primaire sleutels en gegenereerde rij-ID's.

Verwante API-elementen

Geeft de paginagrootte van de database (in bytes) aan die is opgegeven toen de huidige database werd gemaakt (de waarde die is opgegeven voor de parameter pageSizetijdens de aanroep van open() of openAsync() waarmee de database werd gemaakt).

Als de eigenschap connected is ingesteld op false, is de waarde van deze eigenschap 0.

De paginagrootte voor een database kan worden gewijzigd (met de methode open() of openAsync()) totdat de eerste tabel in de database wordt gemaakt.

Verwante API-elementen

Bevat het totale aantal gegevenswijzigingen dat is aangebracht sinds de verbinding met de database werd geopend. Naast wijzigingen die zijn aangebracht door de instructies INSERT, DELETE en UPDATE omvat deze waarde wijzigingen die worden veroorzaakt door triggers.

Wanneer de databaseverbinding wordt gesloten, wordt de waarde weer ingesteld op 0. Wanneer de SQLConnection-instantie niet is verbonden met een databasebestand, is de waarde 0.

Verwante API-elementen

Creëert een SQLConnection-instantie.

Registreert een gebeurtenislistenerobject bij een object EventDispatcher, zodat de listener een melding van een gebeurtenis ontvangt. U kunt gebeurtenislisteners registreren op alle knooppunten in het weergaveoverzicht van een specifiek type gebeurtenis, fase of prioriteit.

Nadat het registreren van een gebeurtenislistener is voltooid, kunt u de prioriteit ervan niet wijzigen door extra aanroepen van addEventListener(). Wanneer u de prioriteit van een listener wilt wijzigen, moet u eerst removeListener() aanroepen. U kunt de listener opnieuw registreren met het nieuwe prioriteitsniveau.

Nadat de listener is geregistreerd, resulteren volgende aanroepen van addEventListener() met een andere waarde voor type of useCapture in het maken van een afzonderlijke listenerregistratie. Wanneer u bijvoorbeeld eerst een listener registreert bij useCapture ingesteld op true, luistert deze alleen tijdens de vastlegfase. Wanneer u addEventListener() opnieuw aanroept met hetzelfde listenerobject maar met useCapture ingesteld op false, hebt u twee afzonderlijke listeners: één die tijdens de vastlegfase luistert en één die tijdens de doel- en terugkoppelfasen luistert.

U kunt geen gebeurtenislistener registeren voor alleen de doel- of terugkoppelfase. Deze fasen worden bij de registratie gekoppeld, omdat terugkoppeling alleen van toepassing is op voorouders van het doelknooppunt.

Wanneer u een gebeurtenislistener niet langer nodig hebt, kunt u deze verwijderen door removeEventListener() aan te roepen; anders kan dit resulteren in geheugenproblemen. Gebeurtenisluisteraars worden niet automatisch uit het geheugen verwijderd, omdat de verzamelaar met ongewenste details de luisteraar niet verwijderd zolang het verzendende object bestaat (behalve als de parameter useWeakReference op true is ingesteld).

Het kopiëren van een instantie EventDispatcher kopieert de daaraan gekoppelde gebeurtenislisteners. (Wanneer uw nieuwe knooppunt een gebeurtenislistener nodig heeft, moet u de listener eraan koppelen na het maken van het knooppunt.) Wanneer u echter een instantie EventDispatcher verplaatst, worden de daaraan gekoppelde listeners mee verplaatst.

Wanneer de gebeurtenislistener wordt geregistreerd op een knooppunt terwijl een gebeurtenis op dit knooppunt wordt verwerkt, wordt de gebeurtenislistener niet geactiveerd tijdens de huidige fase maar kan wel worden geactiveerd in een latere fase in de gebeurtenisstroom, zoals de terugkoppelfase.

Wanneer een gebeurtenislistener wordt verwijderd uit een knooppunt terwijl een gebeurtenis wordt verwerkt op het knooppunt, wordt deze nog steeds geactiveerd door de huidige handelingen. Nadat deze is verwijderd, wordt de gebeurtenislistener niet meer aangeroepen (tenzij deze opnieuw wordt geregistreerd voor toekomstige verwerking).

Parameters

function(evt:Event):void

Verzamelt statistische gegevens over database-indexen en slaat deze op in de database. Deze statistische gegevens kunnen vervolgens worden gebruikt door de functie voor query-optimalisatie (het gedeelte van de database-engine dat de meest efficiënte manier bepaalt om elke instructie uit te voeren). Met behulp van de statistische gegevens kan de functie voor query-optimalisatie betere keuzen maken over welke index(en) moeten worden gebruikt wanneer een bepaalde query wordt uitgevoerd.

Als indexen in een database zijn gedefinieerd, maar de methode analyze() niet is aangeroepen, gebruikt de runtime toch die indexen om instructies uit te voeren. Zonder de aanvullende statistische informatie die door de methode analyze() wordt gegenereerd, kiest de runtime mogelijk niet de meest efficiënte index voor een specifieke query.

Wanneer de gegevens in een tabel veranderen (als resultaat van de instructie INSERT, UPDATE of DELETE), veranderen de bijbehorende indexen van die tabel eveneens. De statistische gegevens die worden gegenereerd door analyze(), worden niet automatisch bijgewerkt. Daarom kan het nuttig zijn om de methode analyze() opnieuw aan te roepen na een groot aantal gegevenswijzigingen. Het voordeel van een nieuwe aanroep van analyze() hangt echter af van diverse factoren, waaronder het aantal indexen dat in een tabel is gedefinieerd, de relatie tussen het aantal gewijzigde rijen en het totale aantal rijen in de tabel, de hoeveelheid variatie in de geïndexeerde gegevens in de tabel en het verschil tussen de gewijzigde gegevens en de oorspronkelijke gegevens.

De parameter resourceName geeft aan of de bewerking wordt uitgevoerd op de indexen van alle gekoppelde databases, een specifieke database of een specifieke tabel.

Telkens wanneer deze methode wordt aangeroepen, worden eerder gegenereerde statistische gegevens verwijderd en worden de gegevens opnieuw gemaakt voor de database of tabel die is opgegeven in de parameter resourceName (of voor alle tabellen in alle verbonden databases als resourceName is null). Deze methoden kan op elk gewenst moment worden aangeroepen terwijl een databaseverbinding is geopend. De bewerking analyze() en de statistische gegevens ervan worden niet opgenomen in een transactie. U kunt analyze() echter beter niet aanroepen als er momenteel een transactie plaatsvindt in de database (de eigenschap inTransaction is ingesteld op true). Dat komt doordat geen rekening wordt gehouden met wijzigingen in gegevens, tabelschema of index die in de transactie zijn uitgevoerd maar nog niet zijn doorgevoerd, door de analyze()-aanroep. De analyze()-gegevens zijn dan ook verouderd zodra de transactie wordt doorgevoerd.

Als u de statistische gegevens die met de methode analyze() zijn gemaakt wilt verwijderen, gebruikt u de methode deanalyze().

Parameters

Verwante API-elementen

Voegt een database toe aan de SQLConnection-instantie, waarbij de nieuwe database de opgegeven naam krijgt. Als u een database koppelt, kan die database worden gebruikt in SQL-instructies die worden uitgevoerd met deze SQLConnection-instantie.

Als er al een database met de opgegeven naam is gekoppeld, resulteert het aanroepen van attach() in een fout. Dezelfde database kan echter meerdere malen worden gekoppeld met unieke namen. Er kunnen slechts tien databases worden gekoppeld aan één SQLConnection-instantie.

Elke SQL-instructie kan worden uitgevoerd met een database die is verbonden via attach() en die kan worden uitgevoerd met hoofddatabase (de database die is verbonden via open() of openAsync()). Een SQL-instructie heeft toegang tot tabellen in elk van de databases die is gekoppeld aan de SQLConnection-instantie in de instructie, waarbij via één instructie toegang kan worden verkregen tot tabellen uit meerdere databases. Wanneer de runtime tabelnamen in een instructie opzoekt, wordt er gezocht in de databases van de SQLConnection-instantie in de volgorde waarin de databases zijn gekoppeld, te beginnen met de database die is verbonden met de methode open() of openAsync(). Gebruik de databasenaam (die is opgegeven in de parameter name van de methode attach()) in de instructie als u expliciet wilt verwijzen naar een tabelnaam.

Als u een database wilt verwijderen die is gekoppeld met de methode attach(), gebruikt u de methode detach(). Wanneer de SQLConnection wordt gesloten (door een aanroep van de methode close()), worden alle gekoppelde databases losgekoppeld.

De gekoppelde database gebruikt dezelfde uitvoeringsmodus (synchroon of asynchroon) als de hoofddatabase, afhankelijk van het feit of de hoofddatabase is verbonden met de methode open() of openAsync().

Parameters

Verwante API-elementen

Begint een transactie waarbinnen alle SQL-instructies die worden uitgevoerd met de database(s) in de verbinding, zijn gegroepeerd.

Standaard wordt elke SQL-instructie uitgevoerd binnen zijn eigen transactie en eindigt de transactie wanneer de uitvoering van de instructie slaagt of mislukt. Als u een transactie maakt met de methode begin(), wordt er een nieuwe, handmatige transactie gemaakt. Vanaf dat punt vinden alle SQL-instructies die worden uitgevoerd met de SQLConnection-instantie, plaats binnen de transactie en kunnen acties of wijzigingen die worden uitgevoerd door de instructies als groep worden doorgevoerd (permanent gemaakt) of teruggedraaid (ongedaan worden gemaakt).

U beëindigt een transactie door de methode commit() of rollback() aan te roepen, afhankelijk van het feit of de wijzigingen die zijn aangebracht door de instructies in de transactie moeten worden doorgevoerd of verwijderd.

Geneste oproepen naar begin() worden genegeerd. U kunt opslagpunten maken door de methode setSavepoint() aan te roepen. Deze zijn zoals bladwijzers in een transactie. U kunt vervolgens SQL-instructies gedeeltelijk toewijzen of terugdraaien door de methode releaseSavepoint() of rollbackToSavepoint aan te roepen. Als echter een transactie wordt gestart door begin() aan te roepen, worden wijzigingen niet permanent toegewezen aan de database tot de methode commit() wordt aangeroepen.

Als de databaseverbinding wordt gesloten terwijl er een transactie is geopend, wordt de transactie automatisch teruggedraaid. (Opmerking: voor AIR 1.1 en eerdere versies wordt een open transactie automatisch vastgelegd wanneer een verbinding wordt gesloten.)

Een transactie is niet beperkt tot instructies die worden uitgevoerd in één database, maar kan instructies bevatten die worden uitgevoerd met verschillende gekoppelde databases.

Parameters

Verwante API-elementen

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

Breekt alle SQL-instructies af die momenteel worden uitgevoerd met databases die zijn verbonden met de SQLConnection-instantie. Deze methode kan worden gebruikt om langdurige of vastgelopen query's te stoppen.

Als er instructies worden uitgevoerd wanneer de methode cancel() wordt aangeroepen, breekt deze methode de bewerkingen in de instructies af en worden onvoltooide updates of transacties teruggedraaid. Als er momenteel geen instructies worden uitgevoerd, draait deze methode een geopende transactie terug, maar doet de methode verder niets.

Parameters

Verwante API-elementen

Sluit de huidige databaseverbinding. Eventuele gekoppelde database worden eveneens losgekoppeld.

Als er een transactie geopend is wanneer close() wordt aangeroepen, wordt de transactie teruggedraaid. Wanneer een SQLConnection-instantie wordt opgeschoond, roept de runtime automatisch close() aan, ook als een AIR-toepassing wordt gesloten terwijl een SQLConnection nog steeds is verbonden met een database.

Parameters

Voert een bestaande transactie door, waardoor acties die worden uitgevoerd door de instructies in de transactie permanent worden toegepast op de database.

U kunt tussenliggende opslagpunten maken door de methodesetSavepoint() aan te roepen. Deze zijn zoals bladwijzers in een transactie. Als u opslagpunten gebruikt, kunt u delen van een transactie toewijzen door de methode releaseSavepoint() aan te roepen of delen van een transactie terugdraaien door de methode rollbackToSavepoint() aan te roepen. Als u echter een transactie hebt geopend met de methode begin(), worden wijzigingen niet permanent opgeslagen in de database tot de volledige transactie is toegewezen door de methode commit() aan te roepen.

Voor een transactie die opslagpunten gebruikt, worden instructies die zijn teruggedraaid met behulp van de methode rollbackToSavepoint() niet toegewezen als de volledige transactie is toegewezen. Instructies die zijn toegewezen met behulp van releaseSavepoint() of waarvan de opslagpunten niet zijn vrijgegeven of teruggedraaid, worden toegewezen aan de database.

Parameters

Verwante API-elementen

Maakt alle ongebruikte ruimte in de database vrij. Wanneer een object (tabel, index of trigger) uit de database wordt verwijderd, laat dit lege ruimte achter. Hierdoor is het databasebestand groter dan nodig is, maar kunnen INSERT-bewerkingen sneller worden uitgevoerd. In de loop der tijd kunnen INSERT- en DELETE-bewerkingen ertoe leiden dat het databasebestand gefragmenteerd raakt, waardoor de schijftoegang tot de database-inhoud trager wordt. Deze methode comprimeert het databasebestand door lege pagina's te verwijderen, tabelgegevens uit te lijnen zodat ze aaneengesloten zijn, en de structuur van het databasebestand op andere manieren op te schonen.

De bewerking compact() kan niet worden uitgevoerd met een gekoppeld databasebestand, maar alleen met het (originele) hoofddatabasebestand dat is geopend door de SQLConnection-instantie. Deze bewerking mislukt als er een actieve transactie is en heeft geen effect op een database in het geheugen.

Parameters

Verwijdert alle statistische gegevens die zijn gemaakt door een aanroep van de methode analyze().

Aangezien de statistische gegevens die zijn gegenereerd door de methode analyze() ruimte in een database innemen, kunt u die ruimte vrijgeven door deanalyze() aan te roepen, bijvoorbeeld nadat diverse indexen of tabellen zijn verwijderd.

Deze bewerking wordt niet opgenomen in een actieve transactie.

Parameters

Verwante API-elementen

Koppelt een aanvullende database los die eerder aan de SQLConnection-instantie is gekoppeld met de methode attach(). Een database kan meerdere malen onder verschillende namen worden gekoppeld. Als in dat geval één verbinding met de database wordt verbroken, blijven de andere verbindingen intact. Een database kan niet worden losgekoppeld als de verbinding een open transactie bevat (als de eigenschap inTransaction is ingesteld op true).

Parameters

Verwante API-elementen

Biedt toegang tot het resultaat van een aanroep van de methode loadSchema() De methode getSchemaResult() werkt als een 'eerst-in, eerst-uit' (FIFO) wachtrij met resultaten. Telkens wanneer de aanroep van de methode loadSchema() wordt voltooid (telkens wanneer de gebeurtenis schema wordt verzonden in de asynchrone uitvoeringsmodus), wordt een nieuw SQLSchemaResult-object aan de wachtrij toegevoegd. Telkens wanneer de methode getSchemaResult() wordt aangeroepen, wordt het oudste resultaat (dat als eerste aan de wachtrij is toegevoegd) geretourneerd en uit de wachtrij verwijderd. Wanneer de wachtrij geen objecten meer bevat, retourneert getSchemaResult() null.

Wanneer de databaseverbinding wordt gesloten, retourneert de methode null.

Verwante API-elementen

Laadt schema-informatie uit de verbonden database of uit gekoppelde databases. Het schema geeft de structuur van de tabellen, kolommen, indexen en triggers van de database aan.

Als u toegang wilt tot het geladen schema, gebruikt u de methode SQLConnection.getSchemaResult().

In de asynchrone uitvoeringsmodus wordt een schema-gebeurtenis verzonden als de bewerking slaagt of een error-gebeurtenis als de bewerking mislukt.

De combinatie van de waarden van de parameters type en name bepaalt het type van de schemagegevens die worden gegenereerd door de methode loadSchema() en dus de waarden van de eigenschappen van de gegenereerde SQLSchemaResult-instantie. In de volgende tabel worden geldige combinatie van type en name vermeld met de schemagegevens die daarbij worden gegenereerd:

Als de combinatie van de argumenten type en name niet overeenkomt met een van de vermelde combinaties, wordt een error-gebeurtenis verzonden in de asynchrone uitvoeringsmodus of wordt een uitzondering gegenereerd in de synchrone uitvoeringsmodus. Als het argument type bijvoorbeeld SQLViewSchema is en het argument name de naam van een tabel (in plaats van de naam van een weergave), wordt er een fout gegenereerd die aangeeft dat de database geen object van het opgegeven type met de opgegeven naam bevat.

Als de database leeg is (geen tabellen, weergaven, triggers of indexen bevat), leidt het aanroepen van de methode loadSchema() tot een fout.

Parameters

Verwante API-elementen

Opent een synchrone verbinding met het databasebestand op de opgegeven locatie in het bestandssysteem, of maakt en opent een nieuw databasebestand op die locatie, of maakt en opent een database in het geheugen. Het maken en openen van de database, en alle andere bewerkingen die worden uitgevoerd met deze SQLConnection-instantie (met inbegrip van instructies en andere bewerkingen die worden uitgevoerd door een SQLStatement-instantie die is gekoppeld aan deze SQLConnection-instantie), worden synchroon uitgevoerd wanneer de database wordt geopend met deze methode. Als u bewerkingen asynchroon wilt uitvoeren, opent u de databaseverbinding in plaats daarvan met de methode openAsync().

Zodra een database is verbonden, gebruikt u een SQLStatement-instantie om SQL-opdrachten uit te voeren. Bewerkingen op databaseniveau, zoals het starten of beëindigen van transacties, het laden van schema-informatie en andere bewerkingen worden uitgevoerd met behulp van de SQLConnection-instantie.

Aan een database die is verbonden met behulp van de methode open(), wordt automatisch de databasenaam 'main' toegewezen. Die naam kan worden gebruikt om expliciet tabelnamen te kwalificeren in SQL-instructies met de notatie [databasenaam].[tabelnaam].

Parameters

Verwante API-elementen

Opent een asynchrone verbinding met het databasebestand op de opgegeven locatie in het bestandssysteem, of maakt en opent een nieuw databasebestand op die locatie, of maakt en opent een database in het geheugen. Het maken en openen van de database, en alle andere bewerkingen die worden uitgevoerd met deze SQLConnection-instantie (met inbegrip van instructies en andere bewerkingen die worden uitgevoerd door een SQLStatement-instantie die is gekoppeld aan deze SQLConnection-instantie), worden asynchroon uitgevoerd wanneer de database wordt geopend met deze methode. Als u bewerkingen synchroon wilt uitvoeren, opent u de databaseverbinding in plaats daarvan met de methode open().

Zodra een database is verbonden, gebruikt u een SQLStatement-instantie om SQL-opdrachten uit te voeren. Bewerkingen op databaseniveau, zoals het starten of beëindigen van transacties, het laden van schema-informatie en andere bewerkingen worden uitgevoerd met behulp van de SQLConnection-instantie.

Aan een database die is verbonden met behulp van de methode openAsync(), wordt automatisch de databasenaam 'main' toegewezen. Die naam kan worden gebruikt om expliciet te verwijzen naar tabelnamen in SQL-instructies met de notatie [databasenaam].[tabelnaam].

Parameters

Verwante API-elementen

Hiermee wijzigt u de coderingssleutel van een gecodeerde database. Deze methode is alleen van invloed op de coderingssleutel van de hoofddatabase (de database die werd gekoppeld met de methode open() of openAsync()). U kunt reencrypt() alleen aanroepen voor een database die tijdens het maken is gecodeerd. Een database die is gemaakt als een gecodeerde database, kan niet worden gedecodeerd. En een database die zonder codering is gemaakt, kan later niet worden gecodeerd.

Het opnieuw coderen wordt in een afzonderlijke transactie uitgevoerd. Als het opnieuw coderen wordt onderbroken, wordt de transactie in de database teruggedraaid en wordt de coderingssleutel niet gewijzigd.

Parameters

Verwante API-elementen

Deze methode legt de SQL-bewerkingen vast die worden gemaakt sinds het meest recente opslagpunt of het genoemde opslagpunt als er een naam is opgegeven.

Let op: totdat de volledige transactie is toegewezen, worden wijzigingen niet permanent in de database opgeslagen. Als de transactie is gestart met behulp van de methode begin(), moet u de methode commit() oproepen om de volledige transactie toe te wijzen. Als de transactie is gestart door setSavepoint() aan te roepen terwijl inTransaction false is, kunt u de volledige transactie voltooien door ofwel de methode commit()aan te roepen of door releaseSavepoint() of rollbackToSavepoint() aan te roepen voor het eerste opslagpunt van de transactie.

Als de code de methode rollback() aanroept, worden alle wijzigingen in de transactie permanent verwijderd, ongeacht of releaseSavepoint() is aangeroepen voordat de transactie is teruggedraaid.

Als deze methode wordt aangeroepen zonder parameters (of met null voor de parameter name) worden alle databasewijzigingen sinds het meest recente naamloze opslagpunt (het meest recente opslagpunt dat is gemaakt door setSavepoint() aan te roepen zonder de parameter name) toegewezen. Als bijvoorbeeld de methode setSavepoint() driemaal wordt aangeroepen, worden er drie opslagpunten ingesteld. Als op dat ogenblik releaseSavepoint() wordt aangeroepen, worden de SQL-bewerkingen die zijn uitgevoerd sinds het derde (nieuwste) opslagpunt, toegewezen.

Als een waarde is opgegeven voor de parameter name, wijst deze methode alle SQL-bewerkingen toe die zijn uitgevoerd sinds het opslagpunt met de opgegeven naam. Als er andere opslagpunten zijn gemaakt die recenter zijn dan het opgegeven opslagpunt, worden bewerkingen die na deze opslagpunten zijn uitgevoerd, ook toegewezen.

Wanneer een opslagpunt vrijgegeven of teruggedraaid wordt, worden deze en andere recente opslagpunten verwijderd. Als code extra SQL-bewerkingen uitvoert nadat een oproep voor een releaseSavepoint() of rollbackToSavepoint() een opslagpunt heeft verwijderd, horen die bewerkingen bij het meest recente overblijvende opslagpunt. (Met andere woorden, ze horen bij het opslagpunt dat vlak voor het verwijderde opslagpunt is gemaakt.) Als er geen opslagpunt overblijft, horen de bewerkingen bij de hoofdtransactie.

Parameters

Verwante API-elementen

Verwijdert een listener uit het object EventDispatcher. Wanneer geen overeenkomende listener is geregistreerd bij het object EventDispatcher, heeft een aanroep van deze methode geen invloed.

Parameters

Draait een bestaande transactie terug die is gemaakt met de methode begin(). Dit betekent dat alle wijzigingen die zijn gemaakt door SQL-instructies in de transactie, worden verwijderd.

Tussenliggende opslagpunten kunnen worden gemarkeerd in een transactie door de methode setSavepoint() aan te roepen. Als u opslagpunten gebruikt, kunt u delen van een transactie toewijzen door de methode releaseSavepoint() aan te roepen of delen van een transactie terugdraaien door rollbackToSavepoint() aan te roepen. Als u echter de methode rollback() aanroept, worden alle wijzigingen in een transactie permanent verwijderd, ongeacht of afzonderlijke opslagpunten zijn vrijgegeven (toegewezen) voordat de transactie is teruggedraaid.

Parameters

Verwante API-elementen

Deze methode draait de SQL-bewerkingen terug die werden gemaakt sinds het meest recente opslagpunt of het genoemde opslagpunt als er een naam opgegeven is.

Let op: als de volledige transactie is toegewezen door de aanroep van de methode commit(), worden alle wijzigingen in de transactie die niet reeds zijn teruggedraaid met behulp van de methode rollbackToSavepoint(), permanent opgeslagen in de database. Bovendien worden door het aanroepen van de methode rollback() alle wijzigingen verwijderd, ongeacht of afzonderlijke opslagpunten zijn vrijgegeven (toegewezen) of teruggedraaid voordat de transactie is teruggedraaid.

Als deze methode wordt aangeroepen zonder parameters (of met null voor de parameter name) worden alle databasewijzigingen sinds het meest recente naamloze opslagpunt (de meest recente aanroep van setSavepoint() zonder de parameterwaarde name) teruggedraaid.

Als een waarde is opgegeven voor de parameter name, draait deze methode alle SQL-bewerkingen terug die zijn uitgevoerd sinds het opslagpunt met de opgegeven naam. Als er andere opslagpunten zijn gemaakt die recenter zijn dan het opgegeven opslagpunt, worden bewerkingen die na deze opslagpunten zijn uitgevoerd, ook teruggedraaid.

Wanneer een opslagpunt vrijgegeven of teruggedraaid wordt, worden deze en andere recente opslagpunten verwijderd. Als code extra SQL-bewerkingen uitvoert nadat een oproep voor een releaseSavepoint() of rollbackToSavepoint() een opslagpunt heeft verwijderd, horen die bewerkingen bij het meest recente overblijvende opslagpunt. (Met andere woorden, ze horen bij het opslagpunt dat vlak voor het verwijderde opslagpunt is gemaakt.) Als er geen opslagpunt overblijft, horen de bewerkingen bij de hoofdtransactie.

Parameters

Verwante API-elementen

Hiermee wordt een opslagpunt gemaakt, dat dient als bladwijzer binnen een databasetransactie. Een opslagpunt vertegenwoordigt een punt binnen een transactie. De set met SQL-bewerkingen die tussen opslagpunten in uitgevoerd, kan afzonderlijk van andere bewerkingen worden toegewezen of teruggedraaid met behulp van de methoden releaseSavepoint() en rollbackToSavepoint(). Op deze manier kunt u met behulp van een opslagpunt een set met SQL-bewerkingen behandelen als een geneste transactie.

Wanneer de methode setSavepoint() wordt aangeroepen en er nog geen transactie is geopend (door de methode begin() aan te roepen), wordt met het aanroepen van deze methode de transactie gestart en wordt een opslagpunt gemaakt aan het begin van de transactie. Als er al een transactie is geopend, wordt door het aanroepen van setSavepoint() een opslagpunt gemaakt binnen de transactie.

Let op: totdat de volledige transactie is toegewezen, worden wijzigingen niet permanent in de database opgeslagen. Als de transactie is gestart met behulp van de methode begin(), moet u de methode commit() oproepen om de volledige transactie toe te wijzen. Als de transactie is gestart door setSavepoint() aan te roepen terwijl inTransaction false is, kunt u de volledige transactie voltooien door de methode commit() aan te roepen. De transactie wordt ook automatisch voltooid wanneer u releaseSavepoint() of rollbackToSavepoint() aanroept voor het opslagpunt dat de transactie heeft gestart.

U kunt een naam opgeven voor een opslagpunt door een naam in te voeren voor de parameter name. Hiermee kunt u alle wijzigingen terugdraaien of toewijzen die sinds het specifieke opslagpunt zijn gemaakt. Als er geen naam is opgegeven (de standaardwaarde), wordt een naamloos opslagpunt gemaakt.

Wanneer een opslagpunt vrijgegeven of teruggedraaid wordt, worden deze en andere recente opslagpunten verwijderd. Als code extra SQL-bewerkingen uitvoert nadat een oproep voor een releaseSavepoint() of rollbackToSavepoint() een opslagpunt heeft verwijderd, horen die bewerkingen bij het meest recente overblijvende opslagpunt. (Met andere woorden, ze horen bij het opslagpunt dat vlak voor het verwijderde opslagpunt is gemaakt.) Als er geen opslagpunt overblijft, horen de bewerkingen bij de hoofdtransactie.

Parameters

Verwante API-elementen

Wordt verzonden als de bewerking analyze() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode attach() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode begin() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode cancel() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode close() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode commit() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode compact() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode deanalyze() correct is voltooid.

Verwante API-elementen

Wordt verzonden wanneer gegevens in een tabel in een van de verbonden databases veranderen als resultaat van de SQL-opdracht DELETE. De gegevenswijziging kan het directe gevolg zijn van een DELETE-instructie die wordt uitgevoerd via een SQLStatement-instantie of indirect worden veroorzaakt doordat een trigger wordt geactiveerd in reactie op de uitvoering van een instructie.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode detach() correct is voltooid.

Verwante API-elementen

Wordt verzonden als een van de asynchrone bewerkingen van het SQLConnection-object resulteert in een fout. De SQLErrorEvent-instantie die wordt verzonden als de eigenschap error van het gebeurtenisobject informatie bevat over de bewerking die werd uitgevoerd en de oorzaak van de fout.

Wordt verzonden wanneer gegevens in een tabel in een van de verbonden databases veranderen als resultaat van de SQL-opdracht INSERT. De gegevenswijziging kan het directe gevolg zijn van een INSERT-instructie die wordt uitgevoerd via een SQLStatement-instantie of indirect wordt veroorzaakt doordat een trigger wordt geactiveerd in reactie op de uitvoering van een instructie.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode openAsync() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode reencrypt() correct is voltooid.

Verwante API-elementen

Wordt verzonden als een bewerking van de aanroep van de methode releaseSavepoint() correct is voltooid.

Verwante API-elementen

Wordt verzonden als de aanroep van de methode rollback() correct is voltooid.

Verwante API-elementen

Wordt verzonden als een bewerking van de aanroep van de methode rollbackToSavepoint() correct is voltooid.

Verwante API-elementen

Wordt verzonden wanneer een aanroep van de methode loadSchema() correct is voltooid en de schemaresultaten gereed zijn.

Verwante API-elementen

Wordt verzonden als een bewerking van de aanroep van de methode setSavepoint() correct is voltooid.

Verwante API-elementen

Wordt verzonden wanneer gegevens in een tabel in een van de verbonden databases veranderen als resultaat van de SQL-opdracht UPDATE. De gegevenswijziging kan het directe gevolg zijn van een UPDATE-instructie die wordt uitgevoerd via een SQLStatement-instantie of indirect worden veroorzaakt doordat een trigger wordt geactiveerd in reactie op de uitvoering van een instructie.

De update-gebeurtenis heeft de volgende eigenschappen:

Verwante API-elementen