SQLiteConnection

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.almworks.sqlite4java
Class SQLiteConnection

java.lang.Object
  com.almworks.sqlite4java.SQLiteConnection

public final class SQLiteConnection
extends java.lang.Object
extends java.lang.Object

SQLiteConnection is a single connection to sqlite database. It wraps the sqlite3* database handle from SQLite C Interface.

Unless otherwise specified, methods are confined to the thread that was used to open the connection. This means that an exception will be thrown if you try to access the method from a different thread.

SQLiteConnection should be expicitly closed before the object is disposed. Failing to do so may result in unpredictable behavior from SQLite.

Once closed with dispose(), the connection cannot be reused and the instance should be forgotten.

Several connections to the same database can be opened by creating several instances of SQLiteConnection.

SQLiteConnection tracks all statements it had prepared. When connection is disposed, it first tries to dispose all prepared statements. If there's an active transaction, it is rolled back.

Author:: Igor Sereda
See Also:: SQLiteStatement, sqlite3*

Field Summary
`static java.lang.String`	`DEFAULT_DB_NAME`

Constructor Summary
`SQLiteConnection()` Creates a connection to an in-memory temporary database.
`SQLiteConnection(java.io.File dbfile)` Creates a connection to the database located in the specified file.

Method Summary
`SQLiteBlob`	`blob(java.lang.String table, java.lang.String column, long rowid, boolean writeAccess)` Convenience method for calling blob() on the currently selected database.
`SQLiteBlob`	`blob(java.lang.String dbname, java.lang.String table, java.lang.String column, long rowid, boolean writeAccess)` Opens a BLOB for reading or writing.
`SQLiteLongArray`	`createArray()` Creates a virtual table within the current session, to represent an array of long values (functionality provided by test_intarray module from SQLite sources).
`SQLiteLongArray`	`createArray(java.lang.String name, boolean cached)` Creates a virtual table within the current session, to represent an array of long values (functionality provided by test_intarray module from SQLite sources).
`java.lang.String`	`debug(java.lang.String sql)` Runs SQL and returns formatted result.
`void`	`dispose()` Closes this connection and disposes all related resources.
`SQLiteConnection`	`exec(java.lang.String sql)` Executes SQL.
`protected void`	`finalize()` The finalize() method is used to warn about a non-closed connection being forgotten.
`boolean`	`getAutoCommit()` Checks if the database is in the auto-commit mode.
`int`	`getChanges()` This method returns the number of database rows that were changed or inserted or deleted by the most recently completed SQL statement in this connection.
`java.io.File`	`getDatabaseFile()` Returns the database file.
`int`	`getErrorCode()` This method returns the error code of the most recently failed operation.
`java.lang.String`	`getErrorMessage()` This method returns the English error message that describes the error returned by `getErrorCode()`.
`long`	`getLastInsertId()` Returns the ROWID of the row, last inserted in this connection (regardless of which statement was used).
`int`	`getLimit(int id)` Returns the current limit for the size of a various constructs for the current connection.
`int`	`getOpenFlags()` Returns the flags that were used to open this connection.
`SQLiteColumnMetadata`	`getTableColumnMetadata(java.lang.String dbName, java.lang.String tableName, java.lang.String columnName)` Returns meta information about a specific column of a database table.
`int`	`getTotalChanges()` This method returns the total number of database rows that were changed or inserted or deleted since this connection was opened.
`SQLiteBackup`	`initializeBackup(java.io.File destinationDbFile)` Initializes backup of the database from this connection to the specified file.
`SQLiteBackup`	`initializeBackup(java.lang.String sourceDbName, java.io.File destinationDbFile, int flags)` Initializes backup of the database with the given name from the current connection to the specified file.
`void`	`interrupt()` This method can be called to interrupt a currently long-running SQL statement, causing it to fail with an exception.
`boolean`	`isDisposed()` Checks if the connection has been disposed.
`boolean`	`isMemoryDatabase()` Checks whether this connection is to an in-memory database.
`boolean`	`isOpen()` Tells whether connection is open.
`boolean`	`isReadOnly()` Checks if this connection is read-only.
`boolean`	`isReadOnly(java.lang.String dbName)` Checks if a database accessed through this connection is read-only.
`void`	`loadExtension(java.io.File extensionFile)` Loads an SQLite extension library using default extension entry point.
`void`	`loadExtension(java.io.File extensionFile, java.lang.String entryPoint)` Loads an SQLite extension library.
`SQLiteConnection`	`open()` Opens the connection, creating database if needed.
`SQLiteConnection`	`open(boolean allowCreate)` Opens the connection, optionally creating the database.
`SQLiteConnection`	`openReadonly()` Opens the connection is read-only mode.
`SQLiteConnection`	`openV2(int flags)` Opens the connection with the specified flags for the sqlite3_open_v2 method.
`SQLiteStatement`	`prepare(SQLParts sql)` Convenience method that prepares a cached statement for the given SQL.
`SQLiteStatement`	`prepare(SQLParts sql, boolean cached)` Prepares an SQL statement.
`SQLiteStatement`	`prepare(java.lang.String sql)` Convenience method that prepares a cached statement for the given SQL.
`SQLiteStatement`	`prepare(java.lang.String sql, boolean cached)` Convenience method that prepares a statement for the given String-based SQL.
`SQLiteProfiler`	`profile()` Starts SQL profiling and returns the profiler class.
`SQLiteConnection`	`setBusyTimeout(long millis)` Sets "busy timeout" for this connection.
`void`	`setExtensionLoadingEnabled(boolean enabled)` Enables or disables SQLite extension loading for this connection.
`int`	`setLimit(int id, int newVal)` Allows the size of various constructs for the current connection to be limited.
`void`	`setStepsPerCallback(int stepsPerCallback)` Sets the frequency of database callbacks during long-running SQL statements.
`SQLiteProfiler`	`stopProfiling()` Stops the profiling and returns the profiler instance with data.
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
`clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

DEFAULT_DB_NAME

public static final java.lang.String DEFAULT_DB_NAME

See Also:: Constant Field Values

Constructor Detail

SQLiteConnection

public SQLiteConnection(java.io.File dbfile)

Creates a connection to the database located in the specified file. Database is not opened by the constructor, and the calling thread is insignificant.

Parameters:: dbfile - database file, or null to create an in-memory database

SQLiteConnection

public SQLiteConnection()

Creates a connection to an in-memory temporary database. Database is not opened by the constructor, and the calling thread is insignificant.

See Also:: SQLiteConnection(java.io.File)

Method Detail

getDatabaseFile

public java.io.File getDatabaseFile()

Returns the database file. This method is thread-safe.

Returns:: the file that hosts the database, or null if database is in memory

isMemoryDatabase

public boolean isMemoryDatabase()

Checks whether this connection is to an in-memory database. This method is thread-safe.

Returns:: true if the connection is to the memory database

setStepsPerCallback

public void setStepsPerCallback(int stepsPerCallback)

Sets the frequency of database callbacks during long-running SQL statements. Database callbacks are currently used to check if the statement has been cancelled.

This method is partially thread-safe: it may be called from a non-confining thread before connection is opened. After connection is opened, is should be called from the confining thread and before any statement has been executed.

Parameters:: stepsPerCallback - the number of internal SQLite cycles in between calls to the progress callback (default 1)
See Also:: sqlite3_progress_callback

setLimit

public int setLimit(int id,
                    int newVal)
             throws SQLiteException

Allows the size of various constructs for the current connection to be limited.

Parameters:: id - identifies the class of the constructs to be limited (use SQLITE_LIMIT_* constants from SQLiteConstants).; newVal - the new limit
Returns:: previous limit
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_limit

getLimit

public int getLimit(int id)
             throws SQLiteException

Returns the current limit for the size of a various constructs for the current connection.

Parameters:: id - identifies the class of the constructs to be limited (use SQLITE_LIMIT_* constants from SQLiteConstants).
Returns:: current limit
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_limit

open

public SQLiteConnection open(boolean allowCreate)
                      throws SQLiteException

Opens the connection, optionally creating the database.

If connection is already open, fails gracefully, allowing connection can be used further.

This method "confines" the connection to the thread in which it has been called. Most of the following method calls to this connection and to its statements should be made only from that thread, otherwise an exception is thrown.

If allowCreate parameter is false, and database file does not exist, method fails with an exception.

Parameters:: allowCreate - if true, database file may be created. For an in-memory database, this parameter must be true.
Returns:: this connection
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_open_v2

open

public SQLiteConnection open()
                      throws SQLiteException

Opens the connection, creating database if needed. See open(boolean) for a full description.

Returns:: this connection
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class

openReadonly

public SQLiteConnection openReadonly()
                              throws SQLiteException

Opens the connection is read-only mode. Not applicable for an in-memory database. See open(boolean) for a full description.

Returns:: this connection
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class

openV2

public SQLiteConnection openV2(int flags)
                        throws SQLiteException

Opens the connection with the specified flags for the sqlite3_open_v2 method. The flags SQLITE_OPEN_xxx are defined in SQLiteConstants and can be ORed together.

This method is provided for future versions compatibility and for open options not otherwise supported by sqlite4java. Use this method only if other open() methods are not sufficient.

In all other respects, this method works exactly like open(boolean), consult documentation to that method for details.

Parameters:: flags - integer flags as defined by sqlite3_open_v2 function
Returns:: this connection
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_open_v2

isOpen

public boolean isOpen()

Tells whether connection is open. This method is thread-safe.

Returns:: true if this connection was successfully opened and has not been disposed

isDisposed

public boolean isDisposed()

Checks if the connection has been disposed. This method is thread-safe.

Returns:: true if this connection has been disposed. Disposed connections can't be used for anything.

isReadOnly

public boolean isReadOnly(java.lang.String dbName)
                   throws SQLiteException

Checks if a database accessed through this connection is read-only.

A database can be read-only if:

it was opened with read-only flag (using openReadonly() or openV2(int) with SQLiteConstants.SQLITE_OPEN_READONLY), or
if the file or file system is read-only.

Parameters:: dbName - database name, or null for the main database
Returns:: true if the specified database is read-only
Throws:: SQLiteException - if the requested database name cannot be found
See Also:: sqlite3_db_readonly

isReadOnly

public boolean isReadOnly()
                   throws SQLiteException

Checks if this connection is read-only. This is a convenience method for calling

A database can be read-only if:

it was opened with read-only flag (using openReadonly() or openV2(int) with SQLiteConstants.SQLITE_OPEN_READONLY), or
if the file or file system is read-only.

This is a convenience method that calls isReadOnly(String) with null parameter, checking the status of the main database of this connection.

Returns:: true if the specified database is read-only
Throws:: SQLiteException - if the requested database name cannot be found
See Also:: isReadOnly(String), sqlite3_db_readonly

getOpenFlags

public int getOpenFlags()

Returns the flags that were used to open this connection.

Returns:: Flags that were used to open the connection.

dispose

public void dispose()

Closes this connection and disposes all related resources. After dispose() is called, the connection cannot be used and the instance should be forgotten.

Calling this method on an already disposed connection does nothing.

If called from a different thread rather from the thread where the connection was opened, this method does nothing. (It used to attempt connection disposal anyway, but that could lead to JVM crash.)

It is better to call dispose() from a different thread, than not to call it at all.

This method does not throw exception even if SQLite returns an error.

See Also:: sqlite3_close

exec

public SQLiteConnection exec(java.lang.String sql)
                      throws SQLiteException

Executes SQL. This method is normally used for DDL, transaction control and similar SQL statements. For querying database and for DML statements with parameters, use prepare(com.almworks.sqlite4java.SQLParts, boolean).

Several statements, delimited by a semicolon, can be executed with a single call.

Do not use this method if your SQL contains non-ASCII characters!

Parameters:: sql - an SQL statement
Returns:: this connection
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_exec

getTableColumnMetadata

public SQLiteColumnMetadata getTableColumnMetadata(java.lang.String dbName,
                                                   java.lang.String tableName,
                                                   java.lang.String columnName)
                                            throws SQLiteException

Returns meta information about a specific column of a database table.

Parameters:: dbName - database name or null; tableName - table name; columnName - column name
Returns:: SQLiteColumnMetadata column metadata
Throws:: SQLiteException - if specified table is actually a view, or if error occurs during this process, or if the requested table or column cannot be found, or if the call violates the contract of this class
See Also:: sqlite3_table_column_metadata

prepare

public SQLiteStatement prepare(SQLParts sql,
                               boolean cached)
                        throws SQLiteException

Prepares an SQL statement. Prepared SQL statement can be used further for putting data into the database and for querying data.

Prepared statements are normally cached by the connection, unless you set cached parameter to false. Because parsing SQL is costly, caching should be used in cases where a single SQL can be executed more than once.

Cached statements are cleared of state before or after they are used.

SQLParts is used to contains the SQL query, yet there are convenience methods that accept String.

Returned statement must be disposed when the calling code is done with it, whether it was cached or not.

Parameters:: sql - the SQL statement, not null; cached - if true, the statement handle will be cached by the connection
Returns:: an instance of SQLiteStatement
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_prepare_v2

prepare

public SQLiteStatement prepare(java.lang.String sql)
                        throws SQLiteException

Convenience method that prepares a cached statement for the given SQL. See prepare(SQLParts, boolean) for details.

Parameters:: sql - an SQL statement, not null
Returns:: an instance of SQLiteStatement
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class

prepare

public SQLiteStatement prepare(java.lang.String sql,
                               boolean cached)
                        throws SQLiteException

Convenience method that prepares a statement for the given String-based SQL. See prepare(SQLParts, boolean) for details.

Parameters:: sql - the SQL statement, not null; cached - if true, the statement handle will be cached by the connection
Returns:: an instance of SQLiteStatement
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class

prepare

public SQLiteStatement prepare(SQLParts sql)
                        throws SQLiteException

Convenience method that prepares a cached statement for the given SQL. See prepare(SQLParts, boolean) for details.

Parameters:: sql - the SQL statement, not null
Returns:: an instance of SQLiteStatement
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class

blob

public SQLiteBlob blob(java.lang.String dbname,
                       java.lang.String table,
                       java.lang.String column,
                       long rowid,
                       boolean writeAccess)
                throws SQLiteException

Opens a BLOB for reading or writing. This method returns an instance of SQLiteBlob, which can be used to read or write a single table cell with a BLOB value. After operations are done, the blob should be disposed.

See SQLite documentation about transactional behavior of the corresponding methods.

Parameters:: dbname - database name, or null for the current database; table - table name, not null; column - column name, not null; rowid - row id; writeAccess - if true, write access is requested
Returns:: an instance of SQLiteBlob for incremental reading or writing
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_blob_open

blob

public SQLiteBlob blob(java.lang.String table,
                       java.lang.String column,
                       long rowid,
                       boolean writeAccess)
                throws SQLiteException

Convenience method for calling blob() on the currently selected database. See blob(String, String, String, long, boolean) for detailed description.

Parameters:: table - table name, not null; column - column name, not null; rowid - row id; writeAccess - if true, write access is requested
Returns:: an instance of SQLiteBlob for incremental reading or writing
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class

setBusyTimeout

public SQLiteConnection setBusyTimeout(long millis)
                                throws SQLiteException

Sets "busy timeout" for this connection. If timeout is defined, then SQLite will not wait to lock the database for more than the specified number of milliseconds.

By default, the timeout is not set.

Parameters:: millis - number of milliseconds for the busy timeout, or 0 to disable the timeout
Returns:: this connection
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_busy_timeout

getAutoCommit

public boolean getAutoCommit()
                      throws SQLiteException

Checks if the database is in the auto-commit mode. In auto-commit mode, transaction is ended after execution of every statement.

Returns:: true if the connection is in auto-commit mode
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_get_autocommit

getLastInsertId

public long getLastInsertId()
                     throws SQLiteException

Returns the ROWID of the row, last inserted in this connection (regardless of which statement was used). If the table has a column of type INTEGER PRIMARY KEY, then that column contains the ROWID. See SQLite docs.

You can also use "last_insert_rowid()" function in SQL statements following the insert.

Returns:: the rowid of the last successful insert, or 0 if nothing has been inserted in this connection
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_last_insert_rowid

getChanges

public int getChanges()
               throws SQLiteException

This method returns the number of database rows that were changed or inserted or deleted by the most recently completed SQL statement in this connection. See SQLite documentation for details.

Returns:: the number of affected rows, or 0
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_changes

getTotalChanges

public int getTotalChanges()
                    throws SQLiteException

This method returns the total number of database rows that were changed or inserted or deleted since this connection was opened. See SQLite documentation for details.

Returns:: the total number of affected rows, or 0
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_total_changes

interrupt

public void interrupt()
               throws SQLiteException

This method can be called to interrupt a currently long-running SQL statement, causing it to fail with an exception.

This method is thread-safe.

There are some important implications from using this method, see SQLite docs.

Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_interrupt

getErrorCode

public int getErrorCode()
                 throws SQLiteException

This method returns the error code of the most recently failed operation. However, this method is rarely needed, as the error code can usually be received from SQLiteException.getErrorCode().

Returns:: error code, or 0
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_errcode, sqlite3_extended_errcode

getErrorMessage

public java.lang.String getErrorMessage()
                                 throws SQLiteException

This method returns the English error message that describes the error returned by getErrorCode().

Returns:: error message, or null
Throws:: SQLiteException - if SQLite returns an error, or if the call violates the contract of this class
See Also:: sqlite3_errmsg

profile

public SQLiteProfiler profile()

Starts SQL profiling and returns the profiler class. If profiling is already started, returns the profiler.

This method is thread-safe, in a sense that it can be called from non-session threads. It's not strongly synchronized, so calling it concurrently may result in duplicate profilers.

Only instances of SQLiteStatement created after this method is called will be profiled (whether SQLite statement is cached or not).

Returns:: the profiler, which will collect stats for all subsequent operations until stopProfiling() is called.

stopProfiling

public SQLiteProfiler stopProfiling()

Stops the profiling and returns the profiler instance with data. If the profiling was not running, returns null.

This method is thread-safe, in a sense that it can be called from non-session threads. It's not strongly synchronized, so calling it concurrently may result in race conditions.

Returns:: the profiler with collected data, or null

createArray

public SQLiteLongArray createArray(java.lang.String name,
                                   boolean cached)
                            throws SQLiteException

Creates a virtual table within the current session, to represent an array of long values (functionality provided by test_intarray module from SQLite sources). After SQLiteLongArray is created, it can be bound consequently several times to a long[], and the virtual table can be used in any SQL. This provides means to make queries with array parameters. For example:

long[] itemIds = ...; SQLiteLongArray array = connection.createArray(); SQLiteStatement st = connection.prepare("SELECT * FROM items WHERE itemId IN " + array.getName()); array.bind(itemIds); while (st.step()) { // read values } st.dispose(); array.dispose();

The array contents is bound using SQLiteLongArray.bind(long[], int, int, boolean, boolean) methods. Binding an array is not a transactional operation; it does not start or stop a transaction, and contents of the array is not affected by ROLLBACK.

You can execute any SQL using array's name (SQLiteLongArray.getName()) as the table name. The actual table is a VIRTUAL TABLE, residing in TEMP database. (Because of that, temp database may be created on disk - you can change that using PRAGMA TEMP_STORE.)

It is possible to execute an SQL that contains several virtual array tables.

Note that the virtual array table does not have a primary key (bound values may have duplicates and come in random order), so be careful about performance.

SQLiteLongArray are cached by the SQLiteConnection, unless cached parameter is set to false. When cached SQLiteLongArray is disposed, it is kept by the connection for further reuse. When a non-cached SQLiteLongArray is disposed, its table is deleted from the TEMP database.

Caution: It's possible to use DROP TABLE on the array virtual table; doing that will make SQL statements that use the table invalid.

Parameters:: name - the name of the table, must be a correct SQL table name, and contains only ASCII characters. If null, a temporary name will be provided automatically (can be later retrieved via SQLiteLongArray.getName().; cached - if true, then a cached array will be used, thus reducing the number of virtual tables and schema changes. If cached is true and a name is given and there's no free array with that name, a new array will be created. If cached is true and name is null, then any free array will be allocated.
Returns:: an instance of SQLiteLongArray, wrapping an empty (unbound) virtual array table
Throws:: SQLiteException - if name is already in use, or if other problem happens
See Also:: test_intarray.h

createArray

public SQLiteLongArray createArray()
                            throws SQLiteException

This is a convenience method that creates an array with an arbitrary name and cached by the connection, equal to call to createArray(null, true). See createArray(String, boolean) for details.

Returns:: an instance of SQLiteLongArray, wrapping an empty (unbound) virtual array table
Throws:: SQLiteException - in case any problem is reported by SQLite, or general contract is broken

initializeBackup

public SQLiteBackup initializeBackup(java.lang.String sourceDbName,
                                     java.io.File destinationDbFile,
                                     int flags)
                              throws SQLiteException

Initializes backup of the database with the given name from the current connection to the specified file.

This method creates a new SQLite connection to the destination file, opens it with the specified flags and initializes an instance of SQLiteBackup for the source and destination connections.

Each successful call to initializeBackup must be followed by a call to SQLiteBackup.dispose(boolean).

The name of the source database is usually "main" for the main database, or "temp" for the temporary database. It can also be the name used in the ATTACH clause for an attached database.

The database that will hold the backup in the destination file is always named "main".

Parameters:: sourceDbName - name of the source database in this connection (usually "main"); destinationDbFile - file to store the backup or null if you want to back up into a in-memory database; flags - flags for opening the connection to the destination database - see openV2(int) for details
Returns:: a new instance of SQLiteBackup
Throws:: SQLiteException - if SQLite return an error, or if the call violates the contract of this class
See Also:: sqlite3_backup_init

initializeBackup

public SQLiteBackup initializeBackup(java.io.File destinationDbFile)
                              throws SQLiteException

Initializes backup of the database from this connection to the specified file.

This is a convenience method, equivalent to initializeBackup("main", destinationDbFile, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE)

Parameters:: destinationDbFile - file to store the backup or null if you want to back up into a in-memory database
Returns:: an instance of SQLiteBackup
Throws:: SQLiteException - if SQLite return an error, or if the call violates the contract of this class

setExtensionLoadingEnabled

public void setExtensionLoadingEnabled(boolean enabled)
                                throws SQLiteException

Enables or disables SQLite extension loading for this connection. By default, extension loading is disabled.

Parameters:: enabled - if true, extensions can be loaded via loadExtension(java.io.File, java.lang.String) function
Throws:: SQLiteException - if extension loading flag cannot be changed
See Also:: enable_load_extension

loadExtension

public void loadExtension(java.io.File extensionFile,
                          java.lang.String entryPoint)
                   throws SQLiteException

Loads an SQLite extension library. Extension loading must be enabled with setExtensionLoadingEnabled(boolean) prior to calling this method.

Parameters:: extensionFile - extension library, not null; entryPoint - entry point function; if null, defaults to "sqlite3_extension_init"
Throws:: SQLiteException - if extension can't be loaded
See Also:: load_extension

loadExtension

public void loadExtension(java.io.File extensionFile)
                   throws SQLiteException

Loads an SQLite extension library using default extension entry point. Extension loading must be enabled with setExtensionLoadingEnabled(boolean) prior to calling this method.

Parameters:: extensionFile - extension library, not null
Throws:: SQLiteException - if extension can't be loaded
See Also:: load_extension

toString

public java.lang.String toString()

Overrides:: toString in class java.lang.Object

finalize

protected void finalize()
                 throws java.lang.Throwable

The finalize() method is used to warn about a non-closed connection being forgotten.

Overrides:: finalize in class java.lang.Object

Throws:: java.lang.Throwable

debug

public java.lang.String debug(java.lang.String sql)

Runs SQL and returns formatted result. This method is added for running an SQL from debugger.

Parameters:: sql - SQL to execute
Returns:: a string containing multiline formatted table with the result

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.almworks.sqlite4java Class SQLiteConnection

DEFAULT_DB_NAME

SQLiteConnection

SQLiteConnection

getDatabaseFile

isMemoryDatabase

setStepsPerCallback

setLimit

getLimit

open

open

openReadonly

openV2

isOpen

isDisposed

isReadOnly

isReadOnly

getOpenFlags

dispose

exec

getTableColumnMetadata

prepare

prepare

prepare

prepare

blob

blob

setBusyTimeout

getAutoCommit

getLastInsertId

getChanges

getTotalChanges

interrupt

getErrorCode

getErrorMessage

profile

stopProfiling

createArray

createArray

initializeBackup

initializeBackup

setExtensionLoadingEnabled

loadExtension

loadExtension

toString

finalize

debug

com.almworks.sqlite4java
Class SQLiteConnection