SQLConnection  - AS3

Indica se la funzione di compressione automatica era abilitata quando il database corrente è stato creato (il valore specificato per il parametro autoCompact nella chiamata open() o openAsync() che ha creato il database). Se questa proprietà è true, lo spazio inutilizzato viene rimosso automaticamente dal file di database dopo ogni operazione di scrittura, al fine di mantenere contenute le dimensioni del file di database. Se la proprietà è false, lo spazio precedentemente occupato dai dati rimossi viene lasciato nel file di database e riutilizzato quando necessario. Anche quando autoCompact èfalse, potete obbligare il database a utilizzare lo spazio inutilizzato chiamando il metodo compact().

Se la proprietà connected è false, questa proprietà viene impostata su false.

Elementi API correlati

Fornisce accesso alle dimensioni della cache per questa connessione, che rappresentano il numero massimo di pagine del disco del database che vengono supportate contemporaneamente dalla memoria. Ogni pagina ha circa 1,5 KB di memoria (a seconda del valore specificato per il parametro pageSize della chiamata al metodo open() o openAsync() che ha creato il database). La dimensione predefinita della cache è 2000. Se un'applicazione sta eseguendo delle operazioni UPDATE o DELETE che modificano molte righe di un database, aumentare le dimensioni della cache può migliorare la velocità (ma provocare un consumo di memoria maggiore).

Elementi API correlati

Indica come i nomi di colonna vengono riportati nel risultato di un'istruzione SELECT.

Le costanti definite nella classe SQLColumnNameStyle rappresentano i valori possibili per questa proprietà:

• SQLColumnNameStyle.LONG indica che i nomi di colonna vengono restituiti nel formato [nome-tabella]_[nome-colonna].
• SQLColumnNameStyle.SHORT specifica che ai nomi di colonna viene assegnato il formato [nome-colonna]. Se sono presenti più colonne con lo stesso nome, all'oggetto risultato viene aggiunta una sola proprietà con tale nome.
• SQLColumnNameStyle.DEFAULT è il valore predefinito. Quando utilizzate questo valore, i nomi delle colonne dei risultati vengono formattati in base al numero di tabelle nell'istruzione SELECT che hanno nomi di colonna simili. Se l'istruzione SELECT include solo una tabella, viene utilizzato il formato nome breve [nome-colonna], e se l'istruzione SELECT include più tabelle unite, ogni volta che si verifica una collisione di nomi dovuta a due nomi di colonna identici, viene utilizzato il formato nome lungo [nome-tabella]_[nome-colonna] per le colonne con nome identico.

Elementi API correlati

Indica se l'istanza SQLConnection presenta una connessione aperta con il file di database.

Elementi API correlati

Indica se questa connessione è al momento coinvolta da una transazione.

Elementi API correlati

Indica se la classe SQLConnection è supportata nella piattaforma corrente o meno.

L'ultimo identificatore di riga generato creato da un'istruzione SQL INSERT. Un identificatore riga viene utilizzato per identificare in modo univoco una riga in una tabella di database. Il valore viene spesso generato dal database.

Il valore è zero se non è collegato alcun database o se non è stata eseguita alcuna istruzione INSERT.

L'identificatore riga per una singola esecuzione dell'istruzione SQL INSERT può essere ottenuto mediante la proprietà lastInsertRowID dell'oggetto SQLResult restituito dal metodo getResult() dell'oggetto SQLStatement (se chiamato dopo che SQLStatement ha inviato il proprio evento result).

Per ulteriori informazioni sulle chiavi primarie e sugli identificatori di riga generati, vedete le sezioni "CREATE TABLE" e "Espressioni" nell'appendice "Supporto di SQL nei database locali".

Elementi API correlati

Indica le dimensioni pagina database (in byte) specificate quando il database corrente è stato creato (il valore specificato per il parametro pageSize nella chiamata open() o openAsync() che ha creato il database).

Se la proprietà connected è false, il valore di questa proprietà è 0.

Le dimensioni della pagina per un database possono essere modificate (mediante i metodi open() o openAsync()) fino a quando non viene creata la prima tabella nel database.

Elementi API correlati

Contiene il numero totale delle modifiche dei dati effettuate a partire dal momento in cui è stata stabilita la connessione al database. Oltre a tenere traccia delle modifiche apportate dalle istruzioni INSERT, DELETE e UPDATE, questo valore include le modifiche attivate dai trigger.

Quando la connessione al database viene chiusa, il valore viene reimpostato su 0. Quando l'istanza SQLConnection non è collegata a un database, il valore è 0.

Elementi API correlati

Crea un'istanza SQLConnection.

Registra un oggetto listener di eventi con un oggetto EventDispatcher, in modo che il listener riceva la notifica di un evento. Potete registrare listener di eventi in tutti i nodi dell'elenco di visualizzazione per un tipo di evento, una fase e una priorità specifiche.

Una volta registrato un listener di eventi, non potete modificarne la priorità mediante chiamate aggiuntive a addEventListener(). Per modificare la priorità di un listener dovete chiamare innanzitutto removeListener(). In seguito potete registrare nuovamente il listener con il nuovo livello di priorità.

Tenete presente che, dopo la registrazione del listener, le successive chiamate a addEventListener() con un valore type o useCapture diverso determinano la creazione di un'altra registrazione per il listener. Ad esempio, se registrate un listener inizialmente con useCapture impostato su true, l'intercettazione avviene solo durante la fase di cattura. Se chiamate di nuovo addEventListener() utilizzando lo stesso oggetto listener ma impostando useCapture su false, ottenete due listener separati: uno rileva gli eventi durante la fase di cattura e l'altro durante la fasi target e di bubbling.

Non potete registrare un listener di eventi solo per la fase target o per la fase di bubbling. Queste fasi vengono accoppiate durante la registrazione perché la propagazione è valida solo per gli antenati del nodo target.

Se il listener di eventi non è più necessario, rimovetelo con una chiamata a removeEventListener() per evitare problemi di memoria. I listener di eventi non vengono eliminati automaticamente dalla memoria perché il garbage collector non rimuove il listener fintantoché esiste l'oggetto che effettua l'invio (a meno che il parametro useWeakReference non sia impostato su true).

Se copiate un'istanza EventDispatcher, i listener di eventi associati all'istanza non vengono copiati (se un nodo appena creato necessita di un listener di eventi, dovete associarlo dopo avere creato il nodo). Se invece spostate un'istanza EventDispatcher, insieme a questa vengono spostati anche i listener di eventi associati.

Se il listener di eventi viene registrato su un nodo mentre questo sta elaborando un evento, il listener di eventi non viene attivato durante la fase corrente ma può esserlo durante una fase successiva del flusso di eventi, ad esempio la fase di bubbling.

Se un listener di eventi viene rimosso da un nodo mentre questo sta elaborando un evento, il listener continua a essere attivato dalle azioni in corso. Dopo che è stato rimosso, il listener di eventi non viene più richiamato (a meno che non venga registrato nuovamente per elaborazioni future).

Parametri

function(evt:Event):void

Raccoglie statistiche relative agli indici di database e li memorizza nel database. Queste statistiche possono essere successivamente utilizzate dall'ottimizzatore delle query (la porzione del motore del database che determina il modo più efficiente per eseguire ogni istruzione). Le statistiche aiutano l'ottimizzatore di query a effettuare scelte migliori sugli indici da utilizzare quando viene eseguita una specifica query.

Se in un database gli indici sono definiti ma il metodo analyze() non è stato chiamato, il runtime utilizza comunque tali indici per eseguire le istruzioni. Tuttavia, senza le informazioni statistiche supplementari generate dal metodo analyze(), il runtime potrebbe non scegliere l'indice più efficiente per una determinata query.

Quando i dati di una tabella cambiano (come risultato di istruzioni INSERT, UPDATE o DELETE), cambiano anche gli indici associati a tale tabella. Le informazioni statistiche generate da analyze() non vengono aggiornate automaticamente. Di conseguenza, dopo un numero elevato di modifiche ai dati, potrebbe essere vantaggioso chiamare ancora il metodo analyze(). Tuttavia, il beneficio ottenuto chiamando nuovamente analyze() dipende da diversi fattori, tra cui il numero di indici definiti in una tabella, la relazione tra il numero di righe modificate e il numero totale di righe nella tabella, l'entità della variazione dei dati indicizzati della tabella e la differenza tra i dati modificati e quelli precedenti alla modifica.

Il parametro resourceName indica se l'operazione deve essere eseguita sugli indici di tutti i database associati, su un database specifico o su una tabella specifica.

Ogni volta che viene chiamato questo metodo, gli eventuali dati statistici creati in precedenza vengono eliminati e ricreati per il database o la tabella specificati nel parametro resourceName (o tutte le tabelle in tutti i database collegati se resourceName è null). Questo metodo può essere chiamato in qualsiasi momento mentre è aperta una connessione a un database. L'operazione analyze() e i relativi dati statistici non vengono inclusi in una transazione; tuttavia, è preferibile non chiamare analyze() quando per il database è in corso una transazione (la proprietà inTransaction è true). Il motivo è che qualunque modifica a dati, schemi di tabella o indice eseguita nella transazione ma per la quale non è ancora stato effettuato il commit, non viene presa in considerazione dalla chiamata ad analyze(), e i dati di analyze() sono scaduti non appena viene effettuato il commit della transazione.

Per rimuovere i dati statistici creati con il metodo analyze(), utilizzate il metodo deanalyze().

Parametri

Elementi API correlati

Aggiunge un altro database all'istanza SQLConnection, assegnando al nuovo database il nome specificato. L'associazione a un database consente di utilizzare il database nelle istruzioni SQL eseguite su questa istanza SQLConnection.

Se un database è già associato mediante il nome specificato, la chiamata ad attach() genera un errore. Tuttavia, lo stesso database potrebbe essere associato più volte mediante nomi univoci. Solo dieci database possono essere associati a una sola istanza SQLConnection.

Qualunque istruzione SQL può essere eseguita su un database collegato mediante attach() che può essere eseguito sul database principale (il database collegato mediante open() o openAsync()). Un'istruzione SQL può accedere alle tabelle di uno qualunque dei database associati all'istanza SQLConnection associata dell'istruzione, comprese le tabelle di più database in una sola istruzione. Quando il runtime risolve i nomi in un'istruzione, cerca tra i database dell'istanza SQLConnection seguendo l'ordine con cui i database sono stati associati, a partire da quello che è stato collegato mediante il metodo open() o openAsync(). Utilizzate il nome del database (specificato nel metodo attach() come parametro name) nell'istruzione per qualificare in modo esplicito un nome di una tabella.

Per rimuovere un database associato mediante il metodo attach(), utilizzate il metodo detach(). Quando chiudete l'istanza SQLConnection (chiamando il metodo close()), tutti i database associati vengono scollegati.

Il database associato ha la stessa modalità di esecuzione (sincrona o asincrona) del database principale, a seconda che il database principale sia stato collegato mediante il metodo open() o il metodo openAsync().

Parametri

Altri esempi

Elementi API correlati

Avvia una transazione attraverso la quale tutte le istruzioni SQL eseguite su uno o più database di connessione vengono raggruppate.

Per impostazione predefinita, ogni istruzione SQL viene eseguita all'interno della relativa transazione, e la transazione termina quando l'esecuzione dell'istruzione ha esito positivo o negativo. Se create una transazione mediante il metodo begin(), viene creata una nuova transazione manuale. Da quel punto in poi, tutte le istruzioni SQL eseguite sull'istanza SQLConnection hanno luogo all'interno della transazione, e per le eventuali operazioni o modifiche effettuate dalle istruzioni può essere effettuato il commit (cioè devono essere rese permanenti) o il ripristino (cioè devono essere annullate) come gruppo.

Per terminare una transazione, chiamate il metodo commit() o rollback(), a seconda che le modifiche apportate dalle istruzioni della transazione debbano essere rese permanenti o annullate.

Le chiamate nidificate a begin() vengono ignorate. Potete creare punti di salvataggio, che sono simili a segnalibri all'interno di una transazione, chiamando il metodo setSavepoint(). Potete quindi salvare in modo permanente (commit) o ripristinare (rollback) parzialmente le istruzioni SQL chiamando il metodo releaseSavepoint() o rollbackToSavepoint(). Se, tuttavia, una transazione viene avviata mediante una chiamata a begin(), le modifiche non vengono salvate in modo permanente nel database finché non chiamate il metodo commit().

Se la connessione al database si chiude mentre una transazione è aperta, AIR ripristina automaticamente la transazione. (Nota: per AIR 1.1 e versioni precedenti, per una transazione aperta viene automaticamente effettuato il commit quando si chiude una connessione).

Una transazione non si limita alle esecuzioni dell'istruzione in un solo database; può includere le istruzioni eseguite in diversi database associati.

Parametri

Elementi API correlati

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

Annulla tutte le istruzioni SQL attualmente in esecuzione sui database connessi all'istanza SQLConnection. Questo metodo può essere utilizzato per interrompere le query la cui esecuzione è molto lunga o che è diventata incontrollabile.

Se ci sono istruzioni in esecuzione quando chiamate il metodo cancel(), questo metodo annulla le operazioni dell'istruzione e gli eventuali aggiornamenti o transazioni incomplete vengono annullate. Se non ci sono istruzioni in esecuzione, quando chiamate questo metodo ripristina una transazione aperta, altrimenti non esegue alcuna operazione.

Parametri

Elementi API correlati

Chiude la connessione database corrente. Tutti i database eventualmente collegati vengono scollegati.

Se è presente una transazione aperta quando si chiama close(), la transazione viene ripristinata. Quando sottoponete un'istanza SQLConnection al processo di garbage collection, il runtime chiama close() automaticamente, compreso il caso in cui un'applicazione AIR sia chiusa mentre un'istanza SQLConnection è ancora collegata a un database.

Parametri

Salva una transazione esistente, in modo che tutte le azioni eseguite dalle istruzioni della transazione rimangano permanentemente applicate al database.

Potete creare punti di salvataggio intermedi, che sono simili a segnalibri in una transazione, chiamando il metodo setSavepoint(). Tramite i punti di salvataggio potete salvare in modo permanente parti di una transazione chiamando il metodo releaseSavepoint() oppure ripristinare parti di una transazione chiamando il metodo rollbackToSavepoint(). Se, tuttavia, una transazione viene aperta utilizzando il metodo begin(), le modifiche non vengono salvate in modo permanente nel database finché non salvate l'intera transazione chiamando il metodo commit().

Per una transazione che utilizza punti di salvataggio, tutte le istruzioni eventualmente ripristinate utilizzando il metodo rollbackToSavepoint() non verranno salvate in modo permanente finché non salvate l'intera transazione. Le istruzioni salvate in modo permanente utilizzando releaseSavepoint(), o i cui punti di salvataggio non sono stati rilasciati o ripristinati, vengono salvate in modo permanente nel database.

Parametri

Elementi API correlati

Recupera tutto lo spazio inutilizzato nel database. Quando un oggetto (tabella, indice o trigger) viene eliminato dal database, lascia dello spazio vuoto. Ciò rende il file di database più grande del necessario, ma può accelerare le operazioni INSERT. Nel tempo, le operazioni INSERT e DELETE possono rendere frammentata la struttura dei file del database, e ciò rallenta l'accesso del disco ai contenuti del database. Questo metodo compatta il file di database, eliminando le pagine libere, allineando i dati delle tabelle in modo che siano contigui, e altrimenti ripulendo la struttura dei file del database.

L'operazione compact() non può essere eseguita su un file di database associato; può essere associata solo sul file di database principale (originale) aperto dall'istanza SQLConnection. Questa operazione ha esito negativo se è presente una transazione attiva, e non ha effetto su un database in memoria.

Parametri

Rimuove tutte le informazioni statistiche create da una chiamata al metodo analyze().

Poiché le statistiche generate dal metodo analyze() occupano spazio in un database, la chiamata a deanalyze() consente di liberare tale spazio, come quando si eliminano diversi indici o tabelle.

Questa operazione non è inclusa nella transazione attiva.

Parametri

Elementi API correlati

Scollega tutti i database aggiuntivi precedentemente collegati all'istanza SQLConnection mediante il metodo attach(). È possibile che lo stesso di database venga associato più volte con nomi diversi. Se scollegate una connessione, le altre rimarranno invariate. Un database non può essere scollegato se sulla connessione è aperta una transazione (se la proprietà inTransaction è true).

Parametri

Altri esempi

Elementi API correlati

Fornisce accesso al risultato di una chiamata al metodo loadSchema(). Il metodo getSchemaResult() si comporta come una coda di risultati in cui il primo elemento in entrata è il primo in uscita. Ogni volta che viene completata la chiamata al metodo loadSchema() (ogni volta che l'evento schema viene inviato in modalità di esecuzione asincrona), un nuovo oggetto SQLSchemaResult viene aggiunto alla coda. Ogni volta che viene chiamato il metodo getSchemaResult(), il primo risultato (cioè quello aggiunto per primo alla coda) viene restituito e rimosso dalla coda. Quando nella coda non rimane più alcun oggetto, getSchemaResult() restituisce null.

Quando la connessione al database viene chiusa, il metodo restituisce null.

Elementi API correlati

Carica le informazioni sullo schema dal database connesso o da tutti gli eventuali database associati. Lo schema indica la struttura delle tabelle, delle colonne, degli indici e dei trigger del database.

Per accedere allo schema caricato, utilizzate il metodo SQLConnection.getSchemaResult().

In modalità di esecuzione asincrona, un evento schema viene inviato se l'operazione ha esito positivo, oppure viene inviato un evento error se l'operazione ha esito negativo.

La combinazione dei valori di parametro type e name determina il tipo di dati di schema che vengono generati dal metodo loadSchema(), e di conseguenza i valori delle proprietà dell'istanza SQLSchemaResult che viene generata. La tabella seguente elenca le coppie type e name valide e i dati dello schema che vengono generati come risultato:

Se la combinazione degli argomenti type e name non corrisponde a una delle combinazioni specificate, viene inviato un evento error in modalità di esecuzione asincrona oppure viene generata un'eccezione in modalità di esecuzione sincrona. Ad esempio, se l'argomento type è SQLViewSchema e l'argomento name è il nome di una tabella (anziché il nome di una vista), viene visualizzato un errore che indica che il database non contiene un oggetto del tipo specificato con il nome specificato.

Se il database è vuoto (cioè, non contiene tabelle, viste, trigger o indici), la chiamata al metodo loadSchema() genera un errore.

Parametri

Elementi API correlati

Apre una connessione sincrona al file del database nella posizione specificata del file system o crea e apre un nuovo file di database nella posizione oppure crea e apre un database in memoria. Le operazioni di creazione e apertura del database, oltre a tutte le altre operazioni eseguite mediante questa istanza SQLConnection (tra cui l'esecuzione delle istruzioni e altre operazioni effettuate da un'istanza SQLStatement associata a questa istanza SQLConnection), vengono eseguite in modo sincrono quando aprite il database con questo metodo. Per eseguire le operazioni in modo asincrono, aprite la connessione del database utilizzando il metodo openAsync().

Dopo aver connesso un database, utilizzate un'istanza SQLStatement per eseguire i comandi SQL. Per eseguire le operazioni a livello di database, come avviare o terminare transazioni, caricare informazioni sullo schema e altre, utilizzate l'istanza SQLConnection.

A un database che viene collegato mediante il metodo open() viene assegnato automaticamente il nome di database "main". Tale nome può essere utilizzato per qualificare in modo esplicito i nomi di tabella nelle istruzioni SQL mediante il formato [nome-database].[nome-tabella].

Parametri

Altri esempi

Elementi API correlati

Apre una connessione asincrona al file del database nella posizione specificata del file system o crea e apre un nuovo file di database nella posizione oppure crea e apre un database in memoria. Le operazioni di creazione e apertura del database, oltre a tutte le altre operazioni eseguite mediante questa istanza SQLConnection (tra cui l'esecuzione delle istruzioni e altre operazioni effettuate da un'istanza SQLStatement associata a questa istanza SQLConnection), vengono eseguite in modo asincrono quando aprite il database con questo metodo. Per eseguire le operazioni in modo sincrono, aprite la connessione del database utilizzando il metodo open().

Dopo aver connesso un database, utilizzate un'istanza SQLStatement per eseguire i comandi SQL. Per eseguire le operazioni a livello di database, come avviare o terminare transazioni, caricare informazioni sullo schema e altre, utilizzate l'istanza SQLConnection.

Un database che viene collegato mediante il metodo openAsync() viene assegnato automaticamente al nome di database "main"; tale nome può essere utilizzato per qualificare in modo esplicito i nomi di tabella nelle istruzioni SQL mediante il formato [nome-database].[nome-tabella].

Parametri

Altri esempi

Elementi API correlati

Cambia la chiave di crittografia di un database crittografato. Questo metodo influisce solo sulla chiave di crittografia del database principale (il database che è stato connesso con il metodo open() o openAsync()). Potete chiamare reencrypt() solo per un database che è stato crittografato quando è stato creato. Una volta che un database è stato creato come crittografato, non può essere decrittografato. Analogamente, un database che viene creato senza crittografia non può essere crittografato in un secondo momento.

L'operazione di ri-crittografia viene eseguita in una transazione a sé. Se il processo di ricrittografia viene interrotto, il database ripristina la transazione e la chiave di crittografia non viene modificata.

Parametri

Altri esempi

Elementi API correlati

Questo metodo salva in modo permanente le operazioni SQL effettuate, a partire dal punto di salvataggio più recente o dal punto di salvataggio con nome, se è stato specificato un nome.

Notate che finché non salvate in modo permanente l'intera transazione, le eventuali modifiche non saranno salvate in modo permanente nel database. Se la transazione viene avviata mediante il metodo begin(), dovete chiamare il metodo commit() per salvare in modo permanente l'intera transazione. Se la transazione viene avviata mediante una chiamata a setSavepoint() mentre inTransaction è false, potete completare l'intera transazione chiamando il metodo commit() o chiamando releaseSavepoint() o rollbackToSavepoint() per il primo punto di salvataggio della transazione.

Se tramite il codice viene chiamato il metodo rollback(), tutte le modifiche nella transazione vengono eliminate in modo permanente, a prescindere dall'aver chiamato o meno releaseSavepoint() prima del ripristino della transazione.

Se il metodo viene chiamato senza parametri (o con il valore null per il parametro name), vengono salvate in modo permanente tutte le modifiche apportate al database dal punto di salvataggio senza nome più recente (il punto di salvataggio più recente creato con una chiamata a setSavepoint() senza il parametro name). Se, ad esempio, il metodo setSavepoint() è stato chiamato tre volte, vengono impostati tre punti di salvataggio. Una chiamata a releaseSavepoint(), a quel punto, salva in modo permanente le operazioni SQL eseguite a partire dal terzo punto di salvataggio (il più recente).

Se viene fornito un valore per il parametro name, questo metodo salva in modo permanente tutte le operazioni SQL eseguite dal punto di salvataggio con il nome specificato. Se sono stati creati altri punti di salvataggio più recenti di quello specificato, vengono salvate in modo permanente anche le operazioni eseguite dopo tali punti di salvataggio.

Dopo che un punto di salvataggio è stato rilasciato o ripristinato, tale punto di salvataggio e gli eventuali altri punti di salvataggio più recenti saranno rimossi. Se tramite il codice vengono eseguite ulteriori operazioni SQL dopo la rimozione di un punto di salvataggio con una chiamata a releaseSavepoint() o rollbackToSavepoint(), tali operazioni appartengono al rimanente punto di salvataggio più recente. (In altre parole, tali operazioni appartengono al punto di salvataggio più recente creato prima del punto di salvataggio rimosso). Se non rimangono punti di salvataggio, le operazioni appartengono alla transazione principale.

Parametri

Elementi API correlati

Rimuove un listener dall'oggetto EventDispatcher. Se non esiste un listener corrispondente registrato nell'oggetto EventDispatcher, la chiamata a questo metodo non ha alcun effetto.

Parametri

Annulla una transazione creata utilizzando il metodo begin(), il che significa che tutte le modifiche effettuate da istruzioni SQL nella transazione verranno eliminate.

I punti di salvataggio intermedi possono essere contrassegnati all'interno di una transazione chiamando il metodo setSavepoint(). Tramite i punti di salvataggio potete salvare in modo permanente parti di una transazione chiamando il metodo releaseSavepoint() oppure ripristinare parti di una transazione chiamando rollbackToSavepoint(). Chiamando tuttavia il metodo rollback(), tutte le modifiche apportate in una transazione vengono eliminate in modo permanente, a prescindere che siano stati rilasciati (salvati in modo permanente) o meno singoli punti di salvataggio prima del ripristino dalla transazione.

Parametri

Elementi API correlati

Ripristina le operazioni SQL effettuate dal punto di salvataggio più recente o dal punto di salvataggio con nome, se è stato specificato un nome.

Notate che se l'intera transazione viene salvata in modo permanente mediante la chiamata al metodo commit(), tutte le modifiche nella transazione che non sono già state ripristinate tramite il metodo rollbackToSavepoint() vengono salvate in modo permanente nel database. Chiamando inoltre il metodo rollback(), tutte le modifiche vengono eliminate in modo permanente, a prescindere che siano stati rilasciati (salvati in modo permanente) o ripristinati singoli punti di salvataggio prima del ripristino dalla transazione.

Se il metodo viene chiamato senza parametri (o con il valore null per il parametro name), vengono ripristinate tutte le modifiche apportate al database dal punto di salvataggio senza nome più recente (la chiamata più recente a setSavepoint() senza specificare un valore per il parametro name).

Se viene fornito un valore per il parametro name, questo metodo ripristina tutte le operazioni SQL eseguite dal punto di salvataggio con il nome specificato. Se sono stati creati altri punti di salvataggio più recenti di quello specificato, vengono ripristinate anche le operazioni eseguite dopo tali punti di salvataggio.

Dopo che un punto di salvataggio è stato rilasciato o ripristinato, tale punto di salvataggio e gli eventuali altri punti di salvataggio più recenti saranno rimossi. Se tramite il codice vengono eseguite ulteriori operazioni SQL dopo la rimozione di un punto di salvataggio con una chiamata a releaseSavepoint() o rollbackToSavepoint(), tali operazioni appartengono al rimanente punto di salvataggio più recente. (In altre parole, tali operazioni appartengono al punto di salvataggio più recente creato prima del punto di salvataggio rimosso). Se non rimangono punti di salvataggio, le operazioni appartengono alla transazione principale.

Parametri

Elementi API correlati

Crea un punto di salvataggio, che è simile a un segnalibro all'interno di una transazione di database. Un punto di salvataggio rappresenta un punto all'interno di una transazione. Il gruppo di operazioni SQL eseguite tra i punti di salvataggio possono essere salvate in modo permanente o ripristinate separatamente da altre operazioni, utilizzando i metodi releaseSavepoint() e rollbackToSavepoint(). In questo modo, tramite un punto di salvataggio potete gestire un gruppo di operazioni SQL come una transazione nidificata.

Quando si chiama il metodo setSavepoint(), se non è già stata aperta una transazione (con una chiamata al metodo begin()), chiamando questo metodo viene avviata una transazione e creato un punto di salvataggio all'avvio della transazione. Se è già aperta una transazione, chiamando setSavepoint() viene creato un punto di salvataggio all'interno della transazione.

Notate che finché non salvate in modo permanente l'intera transazione, le eventuali modifiche non saranno salvate in modo permanente nel database. Se la transazione viene avviata mediante il metodo begin(), dovete chiamare il metodo commit() per salvare in modo permanente l'intera transazione. Se la transazione viene avviata mediante una chiamata a setSavepoint() mentre inTransaction è false, potete completare l'intera transazione chiamando il metodo commit(). La transazione viene completata automaticamente anche quando chiamate releaseSavepoint() o rollbackToSavepoint() per il punto di salvataggio che ha avviato la transazione.

Potete specificare un nome per un punto di salvataggio specificando un valore per il parametro name. In questo modo avete la possibilità di salvare in modo permanente o ripristinare tutte le modifiche a partire da quel punto di salvataggio specifico. Se non si specifica un nome (impostazione predefinita), viene creato un punto di salvataggio senza nome.

Dopo che un punto di salvataggio è stato rilasciato o ripristinato, tale punto di salvataggio e gli eventuali altri punti di salvataggio più recenti saranno rimossi. Se tramite il codice vengono eseguite ulteriori operazioni SQL dopo la rimozione di un punto di salvataggio con una chiamata a releaseSavepoint() o rollbackToSavepoint(), tali operazioni appartengono al rimanente punto di salvataggio più recente. (In altre parole, tali operazioni appartengono al punto di salvataggio più recente creato prima del punto di salvataggio rimosso). Se non rimangono punti di salvataggio, le operazioni appartengono alla transazione principale.

Parametri

Elementi API correlati

Inviato quando un'operazione analyze() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo attach() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo begin() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo cancel() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo close() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo commit() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo compact() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo deanalyze() ha esito positivo.

Elementi API correlati

Inviato quando i dati in qualsiasi tabella di qualsiasi database connesso vengono modificati come risultato di un comando SQL DELETE. La modifica ai dati può essere il diretto risultato di un'istruzione DELETE eseguita attraverso un'istanza SQLStatement o un risultato indiretto provocato dall'attivazione di un trigger come risposta all'esecuzione di un'istruzione.

Elementi API correlati

Inviato quando una chiamata al metodo detach() ha esito positivo.

Elementi API correlati

Inviato quando una delle operazioni asincrone dell'oggetto SQLConnection genera un errore. L'istanza SQLErrorEvent che viene inviata come oggetto evento ha una proprietà error che contiene informazioni sull'operazione che è stata tentata e la causa dell'esito negativo.

Inviato quando i dati in qualsiasi tabella di qualsiasi database connesso vengono modificati come risultato di un comando SQL INSERT La modifica ai dati può essere il diretto risultato di un'istruzione INSERT eseguita attraverso un'istanza SQLStatement o un risultato indiretto provocato dall'attivazione di un trigger come risposta all'esecuzione di un'istruzione.

Elementi API correlati

Inviato quando una chiamata al metodo openAsync() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo reencrypt() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo releaseSavepoint() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo rollback() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo rollbackToSavepoint() ha esito positivo.

Elementi API correlati

Inviato quando una chiamata al metodo loadSchema() ha esito positivo e i risultati dello schema sono pronti.

Elementi API correlati

Inviato quando una chiamata al metodo setSavepoint() ha esito positivo.

Elementi API correlati

Inviato quando i dati in qualsiasi tabella di qualsiasi database connesso vengono modificati come risultato di un comando SQL UPDATE. La modifica dei dati può essere il risultato diretto di un'istruzione UPDATE eseguita attraverso un'istanza SQLStatement o un risultato indiretto provocato da un trigger che attiva una risposta all'esecuzione di un'istruzione.

L'evento update ha le seguenti proprietà:

Elementi API correlati