Database Name Is A File Name

  my $dbh = DBI->connect("dbi:SQLite:dbname=$dbfile","","");

The file is opened in read/write mode, and will be created if it does not exist yet.

Although the database is stored in a single file, the directory containing the database file must be writable by SQLite because the library will create several temporary files there.

If the filename $dbfile is ":memory:", then a private, temporary in-memory database is created for the connection. This in-memory database will vanish when the database connection is closed. It is handy for your library tests.

Note that future versions of SQLite might make use of additional special filenames that begin with the ":" character. It is recommended that when a database filename actually does begin with a ":" character you should prefix the filename with a pathname such as "./" to avoid ambiguity.

If the filename $dbfile is an empty string, then a private, temporary on-disk database will be created. This private database will be automatically deleted as soon as the database connection is closed.

As of 1.41_01, you can pass URI filename (see <https://www.sqlite.org/uri.html>) as well for finer control:

  my $dbh = DBI->connect("dbi:SQLite:uri=file:$path_to_dbfile?mode=rwc");

Note that this is not for remote SQLite database connection. You can only connect to a local database.

Read-Only Database

  use DBD::SQLite::Constants qw/:file_open/;
  my $dbh = DBI->connect("dbi:SQLite:$dbfile", undef, undef, {
    sqlite_open_flags => SQLITE_OPEN_READONLY,
  });

See <https://www.sqlite.org/c3ref/open.html> for details.

As of 1.49_05, you can also make a database read-only by setting "ReadOnly" attribute to true (only) when you connect to a database. Actually you can set it after you connect, but in that case, it can't make the database read-only, and you'll see a warning (which you can hide by turning "PrintWarn" off).

DBD::SQLite And File::Temp

tempfile may be locked exclusively

You may want to use "tempfile()" to create a temporary database filename for DBD::SQLite, but as noted in File::Temp's POD, this file may have an exclusive lock under some operating systems (notably Mac OSX), and result in a "database is locked" error. To avoid this, set EXLOCK option to false when you call tempfile().

  ($fh, $filename) = tempfile($template, EXLOCK => 0);
    

CLEANUP may not work unless a database is disconnected

When you set CLEANUP option to true when you create a temporary directory with "tempdir()" or "newdir()", you may have to disconnect databases explicitly before the temporary directory is gone (notably under MS Windows).

(The above is quoted from the pod of File::Temp.)

If you don't need to keep or share a temporary database, use ":memory:" database instead. It's much handier and cleaner for ordinary testing.

DBD::SQLite and fork()

You shouldn't (re)use a database handle you created (probably to set up a database schema etc) before you fork(). Otherwise, you might see a database corruption in the worst case.

If you need to fork(), (re)open a database after you fork(). You might also want to tweak "sqlite_busy_timeout" and "sqlite_use_immediate_transaction" (see below), depending on your needs.

If you need a higher level of concurrency than SQLite supports, consider using other client/server database engines.

Accessing A Database With Other Tools

  dbish dbi:SQLite:foo.db

On the command line to access the file foo.db.

Alternatively you can install SQLite from the link above without conflicting with DBD::SQLite and use the supplied "sqlite3" command line tool.

Blobs

  use DBI qw(:sql_types);
  my $dbh = DBI->connect("dbi:SQLite:dbfile","","");
  
  my $blob = `cat foo.jpg`;
  my $sth = $dbh->prepare("INSERT INTO mytable VALUES (1, ?)");
  $sth->bind_param(1, $blob, SQL_BLOB);
  $sth->execute();

And then retrieval just works:

  $sth = $dbh->prepare("SELECT * FROM mytable WHERE id = 1");
  $sth->execute();
  my $row = $sth->fetch;
  my $blobo = $row->[1];
  
  # now $blobo == $blob

Functions And Bind Parameters

  my $sth = $dbh->prepare(q{
    SELECT bar FROM foo GROUP BY bar HAVING count(*) > ?;
  });
  $sth->execute(5);

This is because DBD::SQLite assumes that all the bind values are text (and should be quoted) by default. Thus the above statement becomes like this while executing:

  SELECT bar FROM foo GROUP BY bar HAVING count(*) > "5";

There are four workarounds for this.

Use bind_param() explicitly

As shown above in the "BLOB" section, you can always use "bind_param()" to tell the type of a bind value.

  use DBI qw(:sql_types);  # Don't forget this
  
  my $sth = $dbh->prepare(q{
    SELECT bar FROM foo GROUP BY bar HAVING count(*) > ?;
  });
  $sth->bind_param(1, 5, SQL_INTEGER);
  $sth->execute();
    

Add zero to make it a number

This is somewhat weird, but works anyway.

  my $sth = $dbh->prepare(q{
    SELECT bar FROM foo GROUP BY bar HAVING count(*) > (? + 0);
  });
  $sth->execute(5);
    

Use SQL cast() function

This is more explicit way to do the above.

  my $sth = $dbh->prepare(q{
    SELECT bar FROM foo GROUP BY bar HAVING count(*) > cast(? as integer);
  });
  $sth->execute(5);
    

Set "sqlite_see_if_its_a_number" database handle attribute

As of version 1.32_02, you can use "sqlite_see_if_its_a_number" to let DBD::SQLite to see if the bind values are numbers or not.

  $dbh->{sqlite_see_if_its_a_number} = 1;
  my $sth = $dbh->prepare(q{
    SELECT bar FROM foo GROUP BY bar HAVING count(*) > ?;
  });
  $sth->execute(5);
    

You can set it to true when you connect to a database.

  my $dbh = DBI->connect('dbi:SQLite:foo', undef, undef, {
    AutoCommit => 1,
    RaiseError => 1,
    sqlite_see_if_its_a_number => 1,
  });
    

This is the most straightforward solution, but as noted above, existing data in your databases created by DBD::SQLite have not always been stored as numbers, so this *might* cause other obscure problems. Use this sparingly when you handle existing databases. If you handle databases created by other tools like native "sqlite3" command line tool, this attribute would help you.

As of 1.41_04, "sqlite_see_if_its_a_number" works only for bind values with no explicit type.

  my $dbh = DBI->connect('dbi:SQLite:foo', undef, undef, {
    AutoCommit => 1,
    RaiseError => 1,
    sqlite_see_if_its_a_number => 1,
  });
  my $sth = $dbh->prepare('INSERT INTO foo VALUES(?)');
  # '1.230' will be inserted as a text, instead of 1.23 as a number,
  # even though sqlite_see_if_its_a_number is set.
  $sth->bind_param(1, '1.230', SQL_VARCHAR);
  $sth->execute;
    

Placeholders

<https://www.sqlite.org/lang_expr.html#varparam>

Note that a question mark actually means a next unused (numbered) placeholder. You're advised not to use it with other (numbered or named) placeholders to avoid confusion.

  my $sth = $dbh->prepare(
    'update TABLE set a=?1 where b=?2 and a IS NOT ?1'
  );
  $sth->execute(1, 2);

Pragma

journal_mode

You can use this pragma to change the journal mode for SQLite databases, maybe for better performance, or for compatibility.

Its default mode is "DELETE", which means SQLite uses a rollback journal to implement transactions, and the journal is deleted at the conclusion of each transaction. If you use "TRUNCATE" instead of "DELETE", the journal will be truncated, which is usually much faster.

A "WAL" (write-ahead log) mode is introduced as of SQLite 3.7.0. This mode is persistent, and it stays in effect even after closing and reopening the database. In other words, once the "WAL" mode is set in an application or in a test script, the database becomes inaccessible by older clients. This tends to be an issue when you use a system "sqlite3" executable under a conservative operating system.

To fix this, You need to issue "PRAGMA journal_mode = DELETE" (or "TRUNCATE") beforehand, or install a newer version of "sqlite3".

legacy_file_format

If you happen to need to create a SQLite database that will also be accessed by a very old SQLite client (prior to 3.3.0 released in Jan. 2006), you need to set this pragma to ON before you create a database.

reverse_unordered_selects

You can set this pragma to ON to reverse the order of results of SELECT statements without an ORDER BY clause so that you can see if applications are making invalid assumptions about the result order.

Note that SQLite 3.7.15 (bundled with DBD::SQLite 1.38_02) enhanced its query optimizer and the order of results of a SELECT statement without an ORDER BY clause may be different from the one of the previous versions.

synchronous

You can set set this pragma to OFF to make some of the operations in SQLite faster with a possible risk of database corruption in the worst case. See also "Performance" section below.

See <https://www.sqlite.org/pragma.html> for more details.

Foreign Keys

  $dbh->do("PRAGMA foreign_keys = ON");

And you can explicitly disable the feature whenever you like by turning the pragma off:

  $dbh->do("PRAGMA foreign_keys = OFF");

As of this writing, this feature is disabled by default by the SQLite team, and by us, to secure backward compatibility, as this feature may break your applications, and actually broke some for us. If you have used a schema with foreign key constraints but haven't cared them much and supposed they're always ignored for SQLite, be prepared, and please do extensive testing to ensure that your applications will continue to work when the foreign keys support is enabled by default.

See <https://www.sqlite.org/foreignkeys.html> for details.

Transactions

When the AutoCommit flag is on

You're supposed to always use the auto-commit mode, except you explicitly begin a transaction, and when the transaction ended, you're supposed to go back to the auto-commit mode. To begin a transaction, call "begin_work" method, or issue a "BEGIN" statement. To end it, call "commit/rollback" methods, or issue the corresponding statements.

  $dbh->{AutoCommit} = 1;
  
  $dbh->begin_work; # or $dbh->do('BEGIN TRANSACTION');
  
  # $dbh->{AutoCommit} is turned off temporarily during a transaction;
  
  $dbh->commit; # or $dbh->do('COMMIT');
  
  # $dbh->{AutoCommit} is turned on again;
    

When the AutoCommit flag is off

You're supposed to always use the transactional mode, until you explicitly turn on the AutoCommit flag. You can explicitly issue a "BEGIN" statement (only when an actual transaction has not begun yet) but you're not allowed to call "begin_work" method (if you don't issue a "BEGIN", it will be issued internally). You can commit or roll it back freely. Another transaction will automatically begin if you execute another statement.

  $dbh->{AutoCommit} = 0;
  
  # $dbh->do('BEGIN TRANSACTION') is not necessary, but possible
  
  ...
  
  $dbh->commit; # or $dbh->do('COMMIT');
  
  # $dbh->{AutoCommit} stays intact;
  
  $dbh->{AutoCommit} = 1;  # ends the transactional mode
    

This "AutoCommit" mode is independent from the autocommit mode of the internal SQLite library, which always begins by a "BEGIN" statement, and ends by a "COMMIT" or a "ROLLBACK".

Transaction and Database Locking

If you really need to turn off this feature for some reasons, set "sqlite_use_immediate_transaction" database handle attribute to false, and the default "deferred" transaction will be used.

  my $dbh = DBI->connect("dbi:SQLite::memory:", "", "", {
    sqlite_use_immediate_transaction => 0,
  });

Or, issue a "BEGIN" statement explicitly each time you begin a transaction.

See <http://sqlite.org/lockingv3.html> for locking details.

"$sth->finish" and Transaction Rollback

SQLite prohibits "ROLLBACK" of unfinished "SELECT" statements in a transaction (See <http://sqlite.org/lang_transaction.html> for details). So you need to call "finish" before you issue a rollback.

  $sth = $dbh->prepare("SELECT * FROM t");
  $dbh->begin_work;
  eval {
      $sth->execute;
      $row = $sth->fetch;
      ...
      die "For some reason";
      ...
  };
  if($@) {
     $sth->finish;  # You need this for SQLite
     $dbh->rollback;
  } else {
     $dbh->commit;
  }

Processing Multiple Statements At A Time

If you need to process multiple statements at a time, set a "sqlite_allow_multiple_statements" attribute of a database handle to true when you connect to a database, and "do" method takes care of the rest (since 1.30_01, and without creating DBI's statement handles internally since 1.47_01). If you do need to use "prepare" or "prepare_cached" (which I don't recommend in this case, because typically there's no placeholder nor reusable part in a dump), you can look at "$sth->{sqlite_unprepared_statements}" to retrieve what's left, though it usually contains nothing but white spaces.

TYPE statement attribute

As of version 1.61_02, if you set "sqlite_prefer_numeric_type" database handle attribute to true, "TYPE" statement handle attribute returns an array of integer, as an experiment.

Performance

Queries like count(*) and avg(bytes) took fractions of a second to return, but what surprised him most of all was:

  SELECT url, count(*) as count
  FROM access_log
  GROUP BY url
  ORDER BY count desc
  LIMIT 20

To discover the top 20 hit URLs on the site (<http://axkit.org>), and it returned within 2 seconds. He was seriously considering switching his log analysis code to use this little speed demon!

Oh yeah, and that was with no indexes on the table, on a 400MHz PIII.

For best performance be sure to tune your hdparm settings if you are using linux. Also you might want to set:

  PRAGMA synchronous = OFF

Which will prevent SQLite from doing fsync's when writing (which slows down non-transactional writes significantly) at the expense of some peace of mind. Also try playing with the cache_size pragma.

The memory usage of SQLite can also be tuned using the cache_size pragma.

  $dbh->do("PRAGMA cache_size = 800000");

The above will allocate 800M for DB cache; the default is 2M. Your sweet spot probably lies somewhere in between.

Database Handle Attributes

sqlite_version

Returns the version of the SQLite library which DBD::SQLite is using, e.g., "3.26.0". Can only be read.

sqlite_string_mode

SQLite strings are simple arrays of bytes, but Perl strings can store any arbitrary Unicode code point. Thus, DBD::SQLite has to adopt some method of translating between those two models. This parameter defines that translation.

Accepted values are the following constants:

"sqlite_unicode" or "unicode" (deprecated)

If truthy, equivalent to setting "sqlite_string_mode" to DBD_SQLITE_STRING_MODE_UNICODE_NAIVE; if falsy, equivalent to DBD_SQLITE_STRING_MODE_PV.

Prefer "sqlite_string_mode" in all new code.

sqlite_allow_multiple_statements

If you set this to true, "do" method will process multiple statements at one go. This may be handy, but with performance penalty. See above for details.

sqlite_use_immediate_transaction

If you set this to true, DBD::SQLite tries to issue a "begin immediate transaction" (instead of "begin transaction") when necessary. See above for details.

As of version 1.38_01, this attribute is set to true by default. If you really need to use "deferred" transactions for some reasons, set this to false explicitly.

sqlite_see_if_its_a_number

If you set this to true, DBD::SQLite tries to see if the bind values are number or not, and does not quote if they are numbers. See above for details.

sqlite_extended_result_codes

If set to true, DBD::SQLite uses extended result codes where appropriate (see <https://www.sqlite.org/rescode.html>).

sqlite_defensive

If set to true, language features that allow ordinary SQL to deliberately corrupt the database file are prohibited.

Statement Handle Attributes

sqlite_unprepared_statements

Returns an unprepared part of the statement you pass to "prepare". Typically this contains nothing but white spaces after a semicolon. See above for details.

table_info

  $sth = $dbh->table_info(undef, $schema, $table, $type, \%attr);

Returns all tables and schemas (databases) as specified in "table_info" in DBI. The schema and table arguments will do a "LIKE" search. You can specify an ESCAPE character by including an 'Escape' attribute in \%attr. The $type argument accepts a comma separated list of the following types 'TABLE', 'VIEW', 'LOCAL TEMPORARY' and 'SYSTEM TABLE' (by default all are returned). Note that a statement handle is returned, and not a direct list of tables.

The following fields are returned:

TABLE_CAT: Always NULL, as SQLite does not have the concept of catalogs.

TABLE_SCHEM: The name of the schema (database) that the table or view is in. The default schema is 'main', temporary tables are in 'temp' and other databases will be in the name given when the database was attached.

TABLE_NAME: The name of the table or view.

TABLE_TYPE: The type of object returned. Will be one of 'TABLE', 'VIEW', 'LOCAL TEMPORARY' or 'SYSTEM TABLE'.

primary_key, primary_key_info

  @names = $dbh->primary_key(undef, $schema, $table);
  $sth   = $dbh->primary_key_info(undef, $schema, $table, \%attr);

You can retrieve primary key names or more detailed information. As noted above, SQLite does not have the concept of catalogs, so the first argument of the methods is usually "undef", and you'll usually set "undef" for the second one (unless you want to know the primary keys of temporary tables).

foreign_key_info

  $sth = $dbh->foreign_key_info(undef, $pk_schema, $pk_table,
                                undef, $fk_schema, $fk_table);

Returns information about foreign key constraints, as specified in "foreign_key_info" in DBI, but with some limitations :

•

information in rows returned by the $sth is incomplete with respect to the "foreign_key_info" in DBI specification. All requested fields are present, but the content is "undef" for some of them.

The following nonempty fields are returned :

PKTABLE_NAME: The primary (unique) key table identifier.

PKCOLUMN_NAME: The primary (unique) key column identifier.

FKTABLE_NAME: The foreign key table identifier.

FKCOLUMN_NAME: The foreign key column identifier.

KEY_SEQ: The column sequence number (starting with 1), when several columns belong to a same constraint.

UPDATE_RULE: The referential action for the UPDATE rule. The following codes are defined:

  CASCADE              0
  RESTRICT             1
  SET NULL             2
  NO ACTION            3
  SET DEFAULT          4

Default is 3 ('NO ACTION').

DELETE_RULE: The referential action for the DELETE rule. The codes are the same as for UPDATE_RULE.

DEFERRABILITY: The following codes are defined:

  INITIALLY DEFERRED   5
  INITIALLY IMMEDIATE  6
  NOT DEFERRABLE       7

UNIQUE_OR_PRIMARY: Whether the column is primary or unique.

Note: foreign key support in SQLite must be explicitly turned on through a "PRAGMA" command; see "Foreign keys" earlier in this manual.

statistics_info

  $sth = $dbh->statistics_info(undef, $schema, $table,
                                $unique_only, $quick);

Returns information about a table and it's indexes, as specified in "statistics_info" in DBI, but with some limitations :

•

information in rows returned by the $sth is incomplete with respect to the "statistics_info" in DBI specification. All requested fields are present, but the content is "undef" for some of them.

The following nonempty fields are returned :

TABLE_SCHEM: The name of the schema (database) that the table is in. The default schema is 'main', temporary tables are in 'temp' and other databases will be in the name given when the database was attached.

TABLE_NAME: The name of the table

NON_UNIQUE: Contains 0 for unique indexes, 1 for non-unique indexes

INDEX_NAME: The name of the index

TYPE: SQLite uses 'btree' for all it's indexes

ORDINAL_POSITION: Column sequence number (starting with 1).

COLUMN_NAME: The name of the column

ping

  my $bool = $dbh->ping;

returns true if the database file exists (or the database is in-memory), and the database connection is active.

$dbh->sqlite_last_insert_rowid()

Generally you should not be using this method. Use the DBI last_insert_id method instead. The usage of this is:

  $h->last_insert_id($catalog, $schema, $table_name, $field_name [, \%attr ])

Running "$h->last_insert_id("","","","")" is the equivalent of running "$dbh->sqlite_last_insert_rowid()" directly.

$dbh->sqlite_db_filename()

$dbh->sqlite_busy_timeout()

$dbh->sqlite_busy_timeout( $ms )

$dbh->sqlite_create_function( $name, $argc, $code_ref, $flags )

$name

The name of the function. This is the name of the function as it will be used from SQL.

$argc

The number of arguments taken by the function. If this number is -1, the function can take any number of arguments.

$code_ref

This should be a reference to the function's implementation.

$flags

You can optionally pass an extra flag bit to create_function, which then would be ORed with SQLITE_UTF8 (default). As of 1.47_02 (SQLite 3.8.9), only meaning bit is SQLITE_DETERMINISTIC (introduced at SQLite 3.8.3), which can make the function perform better. See C API documentation at <http://sqlite.org/c3ref/create_function.html> for details.

For example, here is how to define a now() function which returns the current number of seconds since the epoch:

  $dbh->sqlite_create_function( 'now', 0, sub { return time } );

After this, it could be used from SQL as:

  INSERT INTO mytable ( now() );

The function should return a scalar value, and the value is treated as a text (or a number if appropriate) by default. If you do need to specify a type of the return value (like BLOB), you can return a reference to an array that contains the value and the type, as of 1.65_01.

  $dbh->sqlite_create_function( 'md5', 1, sub { return [md5($_[0]), SQL_BLOB] } );

REGEXP function

SQLite includes syntactic support for an infix operator 'REGEXP', but without any implementation. The "DBD::SQLite" driver automatically registers an implementation that performs standard perl regular expression matching, using current locale. So for example you can search for words starting with an 'A' with a query like

  SELECT * from table WHERE column REGEXP '\bA\w+'

If you want case-insensitive searching, use perl regex flags, like this :

  SELECT * from table WHERE column REGEXP '(?i:\bA\w+)'

The default REGEXP implementation can be overridden through the "create_function" API described above.

Note that regexp matching will not use SQLite indices, but will iterate over all rows, so it could be quite costly in terms of performance.

$dbh->sqlite_create_collation( $name, $code_ref )

The method's parameters are:

$name

The name of the function exposed to SQL.

$code_ref

Reference to the function's implementation. The driver will check that this is a proper sorting function.

$dbh->sqlite_collation_needed( $code_ref )

  $code_ref->($dbh, $collation_name)

and should register the desired collation using "sqlite_create_collation".

An initial callback is already registered by "DBD::SQLite", so for most common cases it will be simpler to just add your collation sequences in the %DBD::SQLite::COLLATION hash (see section "COLLATION FUNCTIONS" below).

$dbh->sqlite_create_aggregate( $name, $argc, $pkg, $flags )

$name

The name of the aggregate function, this is the name under which the function will be available from SQL.

$argc

This is an integer which tells the SQL parser how many arguments the function takes. If that number is -1, the function can take any number of arguments.

$pkg

This is the package which implements the aggregator interface.

$flags

You can optionally pass an extra flag bit to create_aggregate, which then would be ORed with SQLITE_UTF8 (default). As of 1.47_02 (SQLite 3.8.9), only meaning bit is SQLITE_DETERMINISTIC (introduced at SQLite 3.8.3), which can make the function perform better. See C API documentation at <http://sqlite.org/c3ref/create_function.html> for details.

The aggregator interface consists of defining three methods:

new()

This method will be called once to create an object which should be used to aggregate the rows in a particular group. The step() and finalize() methods will be called upon the reference return by the method.

step(@_)

This method will be called once for each row in the aggregate.

finalize()

This method will be called once all rows in the aggregate were processed and it should return the aggregate function's result. When there is no rows in the aggregate, finalize() will be called right after new().

Here is a simple aggregate function which returns the variance (example adapted from pysqlite):

  package variance;
  
  sub new { bless [], shift; }
  
  sub step {
      my ( $self, $value ) = @_;
  
      push @$self, $value;
  }
  
  sub finalize {
      my $self = $_[0];
  
      my $n = @$self;
  
      # Variance is NULL unless there is more than one row
      return undef unless $n || $n == 1;
  
      my $mu = 0;
      foreach my $v ( @$self ) {
          $mu += $v;
      }
      $mu /= $n;
  
      my $sigma = 0;
      foreach my $v ( @$self ) {
          $sigma += ($v - $mu)**2;
      }
      $sigma = $sigma / ($n - 1);
  
      return $sigma;
  }
  
  $dbh->sqlite_create_aggregate( "variance", 1, 'variance' );

The aggregate function can then be used as:

  SELECT group_name, variance(score)
  FROM results
  GROUP BY group_name;

For more examples, see the DBD::SQLite::Cookbook.

$dbh->sqlite_progress_handler( $n_opcodes, $code_ref )

An example use for this interface is to keep a GUI updated during a large query. The parameters are:

$n_opcodes

The progress handler is invoked once for every $n_opcodes virtual machine opcodes in SQLite.

$code_ref

Reference to the handler subroutine. If the progress handler returns non-zero, the SQLite operation is interrupted. This feature can be used to implement a "Cancel" button on a GUI dialog box.

Set this argument to "undef" if you want to unregister a previous progress handler.

$dbh->sqlite_commit_hook( $code_ref )

When the commit hook callback returns zero, the commit operation is allowed to continue normally. If the callback returns non-zero, then the commit is converted into a rollback (in that case, any attempt to explicitly call "$dbh->rollback()" afterwards would yield an error).

$dbh->sqlite_rollback_hook( $code_ref )

$dbh->sqlite_update_hook( $code_ref )

The callback will be called as

  $code_ref->($action_code, $database, $table, $rowid)

where

$action_code

is an integer equal to either "DBD::SQLite::INSERT", "DBD::SQLite::DELETE" or "DBD::SQLite::UPDATE" (see "Action Codes");

$database

is the name of the database containing the affected row;

$table

is the name of the table containing the affected row;

$rowid

is the unique 64-bit signed integer key of the affected row within that table.

$dbh->sqlite_set_authorizer( $code_ref )

An authorizer is used when preparing SQL statements from an untrusted source, to ensure that the SQL statements do not try to access data they are not allowed to see, or that they do not try to execute malicious statements that damage the database. For example, an application may allow a user to enter arbitrary SQL queries for evaluation by a database. But the application does not want the user to be able to make arbitrary changes to the database. An authorizer could then be put in place while the user-entered SQL is being prepared that disallows everything except SELECT statements.

The callback will be called as

  $code_ref->($action_code, $string1, $string2, $database, $trigger_or_view)

where

$action_code

is an integer that specifies what action is being authorized (see "Action Codes").

$string1, $string2

are strings that depend on the action code (see "Action Codes").

$database

is the name of the database ("main", "temp", etc.) if applicable.

$trigger_or_view

is the name of the inner-most trigger or view that is responsible for the access attempt, or "undef" if this access attempt is directly from top-level SQL code.

$dbh->sqlite_backup_from_file( $filename )

$dbh->sqlite_backup_to_file( $filename )

$dbh->sqlite_backup_from_dbh( $another_dbh )

$dbh->sqlite_backup_to_dbh( $another_dbh )

$dbh->sqlite_enable_load_extension( $bool )

  $dbh->sqlite_enable_load_extension(1);
  $sth = $dbh->prepare("select load_extension('libsqlitefunctions.so')")
  or die "Cannot prepare: " . $dbh->errstr();

$dbh->sqlite_load_extension( $file, $proc )

If the extension uses SQLite mutex functions like "sqlite3_mutex_enter", then the extension should be compiled with the same "SQLITE_THREADSAFE" compile-time setting as this module, see "DBD::SQLite::compile_options()".

$dbh->sqlite_trace( $code_ref )

The callback will be called as

  $code_ref->($statement)

where

$statement

is a UTF-8 rendering of the SQL statement text as the statement first begins executing.

Additional callbacks might occur as each triggered subprogram is entered. The callbacks for triggers contain a UTF-8 SQL comment that identifies the trigger.

See also "TRACING" in DBI for better tracing options.

$dbh->sqlite_profile( $code_ref )

The callback will be called as

  $code_ref->($statement, $elapsed_time)

where

$statement

is the original statement text (without bind parameters).

$elapsed_time

is an estimate of wall-clock time of how long that statement took to run (in milliseconds).

This method is considered experimental and is subject to change in future versions of SQLite.

See also DBI::Profile for better profiling options.

$dbh->sqlite_table_column_metadata( $dbname, $tablename, $columnname )

$dbh->sqlite_db_status()

$sth->sqlite_st_status()

  my $status = $sth->sqlite_st_status();
  my $cur = $status->{fullscan_step};

You may also pass 0 as an argument to reset the status.

$dbh->sqlite_db_config( $id, $new_integer_value )

  use DBD::SQLite::Constants qw/:database_connection_configuration_options/;
  
  my $dbh = DBI->connect('dbi:SQLite::memory:');

  # This disables language features that allow ordinary SQL
  # to deliberately corrupt the database file
  $dbh->sqlite_db_config( SQLITE_DBCONFIG_DEFENSIVE, 1 );
  
  # This disables two-arg version of fts3_tokenizer.
  $dbh->sqlite_db_config( SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 0 );

"sqlite_db_config" returns the new value after the call. If you just want to know the current value without changing anything, pass a negative integer value.

  my $current_value = $dbh->sqlite_db_config( SQLITE_DBCONFIG_DEFENSIVE, -1 );

As of this writing, "sqlite_db_config" only supports options that set an integer value. "SQLITE_DBCONFIG_LOOKASIDE" and "SQLITE_DBCONFIG_MAINDBNAME" are not supported. See also "https://www.sqlite.org/capi3ref.html#sqlite3_db_config" for details.

$dbh->sqlite_create_module()

$dbh->sqlite_limit( $category_id, $new_value )

$dbh->sqlite_get_autocommit()

$dbh->sqlite_txn_state()

DBD::SQLite::compile_options()

DBD::SQLite::sqlite_status()

  my $status = DBD::SQLite::sqlite_status();
  my $cur  = $status->{memory_used}{current};
  my $high = $status->{memory_used}{highwater};

You may also pass 0 as an argument to reset the status.

DBD::SQLite::strlike($pattern, $string, $escape_char), DBD::SQLite::strglob($pattern, $string)

Authorizer Return Codes

  OK
  DENY
  IGNORE

Action Codes

  # constant              string1         string2
  # ========              =======         =======
  CREATE_INDEX            Index Name      Table Name
  CREATE_TABLE            Table Name      undef
  CREATE_TEMP_INDEX       Index Name      Table Name
  CREATE_TEMP_TABLE       Table Name      undef
  CREATE_TEMP_TRIGGER     Trigger Name    Table Name
  CREATE_TEMP_VIEW        View Name       undef
  CREATE_TRIGGER          Trigger Name    Table Name
  CREATE_VIEW             View Name       undef
  DELETE                  Table Name      undef
  DROP_INDEX              Index Name      Table Name
  DROP_TABLE              Table Name      undef
  DROP_TEMP_INDEX         Index Name      Table Name
  DROP_TEMP_TABLE         Table Name      undef
  DROP_TEMP_TRIGGER       Trigger Name    Table Name
  DROP_TEMP_VIEW          View Name       undef
  DROP_TRIGGER            Trigger Name    Table Name
  DROP_VIEW               View Name       undef
  INSERT                  Table Name      undef
  PRAGMA                  Pragma Name     1st arg or undef
  READ                    Table Name      Column Name
  SELECT                  undef           undef
  TRANSACTION             Operation       undef
  UPDATE                  Table Name      Column Name
  ATTACH                  Filename        undef
  DETACH                  Database Name   undef
  ALTER_TABLE             Database Name   Table Name
  REINDEX                 Index Name      undef
  ANALYZE                 Table Name      undef
  CREATE_VTABLE           Table Name      Module Name
  DROP_VTABLE             Table Name      Module Name
  FUNCTION                undef           Function Name
  SAVEPOINT               Operation       Savepoint Name

Definition

Builtin collation sequences

BINARY

Compares string data using memcmp(), regardless of text encoding.

NOCASE

The same as binary, except the 26 upper case characters of ASCII are folded to their lower case equivalents before the comparison is performed. Note that only ASCII characters are case folded. SQLite does not attempt to do full UTF case folding due to the size of the tables required.

RTRIM

The same as binary, except that trailing space characters are ignored.

In addition, "DBD::SQLite" automatically installs the following collation sequences :

perl

corresponds to the Perl "cmp" operator

perllocale

Perl "cmp" operator, in a context where "use locale" is activated.

Usage

  CREATE TABLE foo(
      txt1 COLLATE perl,
      txt2 COLLATE perllocale,
      txt3 COLLATE nocase
  )

or

  SELECT * FROM foo ORDER BY name COLLATE perllocale

Unicode handling

  my $dbh = DBI->connect(
      "dbi:SQLite:dbname=foo", "", "",
      {
          RaiseError     => 1,
          sqlite_unicode => 1,
      }
  );

Adding user-defined collations

To avoid calling these functions every time a $dbh handle is created, "DBD::SQLite" offers a simpler interface through the %DBD::SQLite::COLLATION hash : just insert your own collation functions in that hash, and whenever an unknown collation name is encountered in SQL, the appropriate collation function will be loaded on demand from the hash. For example, here is a way to sort text values regardless of their accented characters :

  use DBD::SQLite;
  $DBD::SQLite::COLLATION{no_accents} = sub {
    my ( $a, $b ) = map lc, @_;
    tr[����������������������������]
      [aaaaaacdeeeeiiiinoooooouuuuy] for $a, $b;
    $a cmp $b;
  };
  my $dbh  = DBI->connect("dbi:SQLite:dbname=dbfile");
  my $sql  = "SELECT ... FROM ... ORDER BY ... COLLATE no_accents");
  my $rows = $dbh->selectall_arrayref($sql);

The builtin "perl" or "perllocale" collations are predefined in that same hash.

The COLLATION hash is a global registry within the current process; hence there is a risk of undesired side-effects. Therefore, to prevent action at distance, the hash is implemented as a "write-only" hash, that will happily accept new entries, but will raise an exception if any attempt is made to override or delete a existing entry (including the builtin "perl" and "perllocale").

If you really, really need to change or delete an entry, you can always grab the tied object underneath %DBD::SQLite::COLLATION --- but don't do that unless you really know what you are doing. Also observe that changes in the global hash will not modify existing collations in existing database handles: it will only affect new requests for collations. In other words, if you want to change the behaviour of a collation within an existing $dbh, you need to call the "create_collation" method directly.

Leak Detection

Stream API for Blobs

Support for custom callbacks for R-Tree queries