DBD::SQLite(3)

💖 NAME 💖

Hiii bestie, you're reading DBD::SQLite(3) from the User Contributed Perl Documentation — and it's literally the manual for DBD::SQLite, the Self-contained RDBMS in a DBI Driver. No cap, that's the whole name.

✨ SYNOPSIS ✨

Slap this in your code and you're connected:

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

🦋 DESCRIPTION 🦋

SQLite is a public domain file-based relational database engine that you can find at https://www.sqlite.org/. It's giving iconic, honestly.

DBD::SQLite is a Perl DBI driver for SQLite, and it includes the entire thing in the distribution. So to get a fast transaction capable RDBMS working for your perl project, you simply have to install this module, and nothing else. That's the vibe: one install, whole database engine. 💅

SQLite supports the following features:

• Implements a large subset of SQL92 — see https://www.sqlite.org/lang.html for details.
• A complete DB in a single disk file — everything for your database is stored in a single disk file, making it easier to move things around than with DBD::CSV.
• Atomic commit and rollback — yes, DBD::SQLite is small and light, but it supports full transactions!
• Extensible — user-defined aggregate or regular functions can be registered with the SQL parser.

There's lots more to it, so please refer to the docs on the SQLite web page, listed above, for SQL details. Also refer to DBI for details on how to use DBI itself. The API works like every DBI module does. However, currently many statement attributes are not implemented or are limited by the typeless nature of the SQLite database.

🔥 SQLITE VERSION 🔥

DBD::SQLite is usually compiled with a bundled SQLite library (SQLite version 3.46.1 as of this release) for consistency. However, a different version of SQLite may sometimes be used for some reasons like security, or some new experimental features. So don't assume, bestie — check.

You can look at $DBD::SQLite::sqlite_version ("3.x.y" format) or $DBD::SQLite::sqlite_version_number ("3xxxyyy" format) to find which version of SQLite is actually used. You can also check DBD::SQLite::Constants::SQLITE_VERSION_NUMBER().

You can also find how the library is compiled by calling DBD::SQLite::compile_options() (see below).

🌈 NOTABLE DIFFERENCES FROM OTHER DRIVERS 🌈

🎀 Database Name Is A File Name 🎀

SQLite creates a file per a database. You should pass the "path" of the database file (with or without a parent directory) in the DBI connection string (as a database "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. Important detail, okay?

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 🫶

You can set sqlite_open_flags (only) when you connect to a 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 🧚

When you use File::Temp to create a temporary file/directory for SQLite databases, you need to remember:

🍓 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() 💀

Follow the advice in the SQLite FAQ (https://sqlite.org/faq.html).

Under Unix, you should not carry an open SQLite database across a fork() system call into the child process. Problems will result if you do.

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. Not cute at all. 😭

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 👑

To access the database from the command line, try using "dbish" which comes with the DBI::Shell module. Just type:

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 💜

As of version 1.11, blobs should "just work" in SQLite as text columns. However this will cause the data to be treated as a string, so SQL statements such as length(x) will return the length of the column as a NUL terminated string, rather than the size of the blob in bytes. In order to store natively as a BLOB use the following code:

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 🦋

As of this writing, a SQL that compares a return value of a function with a numeric bind value like this doesn't work as you might expect.

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 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 🌟

SQLite supports several placeholder expressions, including ? and :AAAA. Consult the DBI and SQLite documentation for details.

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 💖

okay so SQLite has a whole set of “Pragma”s that literally modify how it operates or let you query its internal data. These are SQLite-specific and are not likely to work with other DBD libraries, but bestie, some of these are genuinely useful, including:

🌸 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 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 the “Performance” section below.

⚠️ bestie, that corruption risk is real in the worst case. Not trying to scare you, just keeping it honest 💀

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

---

💅 Foreign Keys 💅

SQLite has started supporting foreign key constraints since 3.6.19 (released on Oct 14, 2009; bundled in DBD::SQLite 1.26_05). To be exact, SQLite has long been able to parse a schema with foreign keys, but the constraints has not been enforced. Now you can issue a foreign_keys pragma to enable this feature and enforce the constraints, preferably as soon as you connect to a database and you’re not in a transaction:

$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 🫶

DBI/DBD::SQLite’s transactions may be a bit confusing. They behave differently according to the status of the AutoCommit flag:

💖 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 🔥

The default transaction behavior of SQLite is “deferred”, that means, locks are not acquired until the first read or write operation, and thus it is possible that another thread or process could create a separate transaction and write to the database after the BEGIN on the current thread has executed, and eventually cause a deadlock. To avoid this, DBD::SQLite internally issues a BEGIN IMMEDIATE if you begin a transaction by calling begin_work or by turning off AutoCommit (since 1.38_01).

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 🫶

As the DBI doc says, you almost certainly do not need to call finish in DBI method if you fetch all rows (probably in a loop). However, there are several exceptions to this rule, and rolling-back of an unfinished SELECT statement is one of such exceptional cases.

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 🧚

DBI’s statement handle is not supposed to process multiple statements at a time. So if you pass a string that contains multiple statements (a “dump”) to a statement handle (via prepare or do), DBD::SQLite only processes the first statement, and discards the rest.

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 🦋

Because of historical reasons, DBD::SQLite’s TYPE statement handle attribute returns an array ref of string values, contrary to the DBI specification. This value is also less useful for SQLite users because SQLite uses dynamic type system (that means, the datatype of a value is associated with the value itself, not with its container).

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 👑

SQLite is fast, very fast. Matt processed his 72MB log file with it, inserting the data (400,000+ rows) by using transactions and only committing every 1000 rows (otherwise the insertion is quite slow), and then performing queries on the data.

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

💅 DRIVER PRIVATE ATTRIBUTES 💅

ok so these are the special little knobs that only this driver has, and they're genuinely so useful, bestie, you're gonna love them 🫶

🗄️ Database Handle Attributes

⭐ sqlite_version

Returns the version of the SQLite library which DBD::SQLite is using, like for example "3.26.0". Read-only, so no touching — it's giving "look but don't touch" energy. 👀

🌈 sqlite_string_mode

okay so this one is a whole thing and it's important, so sit with me for a sec 🧚

SQLite strings are just simple arrays of bytes, fr fr. But Perl strings? They can hold any arbitrary Unicode code point. So obviously somebody's gotta translate between those two completely different models, and this parameter is literally the one that defines how that translation goes down.

The accepted values are these constants, and yes you import them from DBD::SQLite::Constants:

• DBD_SQLITE_STRING_MODE_BYTES — every string is assumed to be bytes, periodt. If a Perl string has any code point above 255, it will throw an exception at you 😭. This is the move for Latin-1 strings, binary data, pre-encoded UTF-8 strings, that whole crowd.
• DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK — every Perl string gets encoded to UTF-8 before SQLite ever sees it. And when SQLite hands strings back to Perl, Perl tries to decode them as UTF-8. If any of those strings turn out to not be valid UTF-8, you get a warning and the string is left undecoded. Rude, but okay. ✨ This one's appropriate for strings that got decoded into characters via, like, decode in Encode.

also real talk: because SQLite's type system is lowkey bizarre (see <https://www.sqlite.org/datatype3.html>), if you want to keep blob-style behavior for certain columns under DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK — say, storing images in the database 🙈 — you HAVE to say so explicitly with the 3-argument form of bind_param in DBI when you're doing updates:

use DBI qw(:sql_types);
use DBD::SQLite::Constants ':dbd_sqlite_string_mode';
$dbh->{sqlite_string_mode} = DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK;
my $sth = $dbh->prepare("INSERT INTO mytable (blobcolumn) VALUES (?)");

# Binary_data will be stored as is.
$sth->bind_param(1, $binary_data, SQL_BLOB);

🚨 and listen: defining the column type as BLOB in the DDL is not sufficient. Not even a little. Do the bind_param thing.

• DBD_SQLITE_STRING_MODE_UNICODE_STRICT — same vibe as DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK, except it usually throws an exception instead of just warning when SQLite sends invalid UTF-8. (Caveat: in Perl callbacks from SQLite we still warn instead. Consistency is a myth 💀)
• DBD_SQLITE_STRING_MODE_UNICODE_NAIVE — also like DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK, but it uses a "naïve" UTF-8 decoding method that skips validation entirely. It's marginally faster than a validated decode but it can also corrupt Perl itself! 😭 Like, actually. Careful.
• DBD_SQLITE_STRING_MODE_PV (this is the default, but DO NOT USE it) — it's like DBD_SQLITE_STRING_MODE_BYTES, except when translating Perl strings to SQLite it just hands SQLite the Perl string's internal byte buffer. Which is bad. But it's been the default for many years and changing it would break existing applications, so here we are. 💀

🕰️ sqlite_unicode or unicode (deprecated)

If it's truthy, it's equivalent to setting sqlite_string_mode to DBD_SQLITE_STRING_MODE_UNICODE_NAIVE. If it's falsy, it's equivalent to DBD_SQLITE_STRING_MODE_PV.

💜 bestie, prefer sqlite_string_mode in all new code. This one is deprecated, it's giving legacy.

🔥 sqlite_allow_multiple_statements

Set this to true and the do method will process multiple statements in one go. Handy? Absolutely. Free? Nope — there's a performance penalty. (See above for the details, iykyk.)

⚡ sqlite_use_immediate_transaction

Set this to true and DBD::SQLite tries to issue a begin immediate transaction (instead of just begin transaction) when it's necessary. See above for the deets.

As of version 1.38_01, this attribute is true by default. So if you genuinely need deferred transactions for some reason, you gotta set this to false explicitly. No cap.

🔢 sqlite_see_if_its_a_number

Set this true and DBD::SQLite tries to figure out whether your bind values are numbers or not, and it does not quote them if they are numbers. See above for details.

🧾 sqlite_extended_result_codes

Set to true and DBD::SQLite uses extended result codes where it makes sense (see <https://www.sqlite.org/rescode.html>). More detail, more info, more everything ✨

🛡️ sqlite_defensive

Set to true and language features that would let ordinary SQL deliberately corrupt the database file are prohibited. Which — yeah — good. Keep that on if you're nervous. 🔒

---

📄 Statement Handle Attributes

🎀 sqlite_unprepared_statements

Returns the unprepared part of the statement you passed to prepare. Typically that's literally nothing but white spaces after a semicolon, so don't get too excited. See above for details.

---

🌸 METHODS 🌸

ok also go look at the DBI documentation for the details on all the other common methods, because those aren't getting re-explained here 🫶

📊 table_info

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

Returns all the tables and schemas (databases) exactly as specified in table_info in DBI. The schema and table arguments will do a LIKE search — yes, a LIKE search, so wildcards work like you'd expect. You can specify an ESCAPE character by including an 'Escape' attribute inside \%attr. The $type argument accepts a comma-separated list of these types: 'TABLE', 'INDEX', 'VIEW', 'TRIGGER', 'LOCAL TEMPORARY' and 'SYSTEM TABLE' — and by default all of them come back. 🎉

heads up: you get a statement handle back, NOT a direct list of tables. Different thing. Don't @ me.

The following fields are returned:

• TABLE_CAT: Always NULL, because SQLite does not have the concept of catalogs. Ever. At all. 💀
• TABLE_SCHEM: The name of the schema (database) that the table or view lives in. The default schema is 'main', temporary tables are in 'temp', and other databases will be under the name given when the database was attached.
• TABLE_NAME: The name of the table or view. Self-explanatory, slay.
• TABLE_TYPE: The type of object returned. Will be one of 'TABLE', 'INDEX', 'VIEW', 'TRIGGER', '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 grab the primary key names, or get the more detailed info version if you're nosy (affectionate). And like we said above, SQLite does not have the concept of catalogs, so that first argument is usually undef, and you'll usually set undef for the second one too — unless you're out here wanting to know the primary keys of temporary tables, in which case, icon behavior, go off 👑

🔗 foreign_key_info

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

Returns info about foreign key constraints, as specified in foreign_key_info in DBI — but with some limitations, because of course there are 🙈:

• the information in the rows returned by the $sth is incomplete with respect to the foreign_key_info in DBI specification. All the requested fields are present, but the content is undef for some of them. It's giving "we have that at home" energy.

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, for when several columns belong to the same constraint.
• UPDATE_RULE: The referential action for the UPDATE rule. These are the defined codes:

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

The default is 3 ('NO ACTION').

• DELETE_RULE: The referential action for the DELETE rule. Codes are the same as for UPDATE_RULE. Same list, same numbers, no surprises.
• DEFERRABILITY: These are the defined codes:

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. It is not on by default, bestie, do not get caught out.

📈 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 yeah, with some limitations again:

• the information in the rows returned by the $sth is incomplete with respect to the statistics_info in DBI specification. All the requested fields are present, but the content is undef for some of them. Same situation as above, sorry babe.

The following nonempty fields are returned:

• TABLE_SCHEM: The name of the schema (database) 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. All of them. Every single one. 🌳
• 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. Both conditions, bestie. It's an "and", not an "or". ✨

---

🧚 DRIVER PRIVATE METHODS 🧚

The following methods can be called via the func() method with a little tweak, but heads up: the use of the func() method is now discouraged by the DBI author for various reasons (see DBI's document <https://metacpan.org/pod/DBI::DBD#Using-install_method()-to-expose-driver-private-methods> for the details).

So if you're on DBI >= 1.608, just use these sqlite_ methods directly, they're right there. If you're stuck needing an older DBI, you can call them like this:

$dbh->func( ..., "(method name without sqlite_ prefix)" );

🌟 Exception: sqlite_trace should always be called as-is, even with the func() method — to avoid conflict with DBI's trace() method. That one doesn't get the prefix stripped, ok?

$dbh->func( ..., "sqlite_trace");

🧸 $dbh->sqlite_last_insert_rowid()

This method returns the last inserted rowid. If you specified an INTEGER PRIMARY KEY as the first column in your table, that's the column that gets returned. Otherwise it's the hidden ROWID column. See the SQLite docs for the details. 📚

Generally though? You should not be using this method. Use the DBI last_insert_id method instead. The usage 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. Same energy, more DBI-approved. 💅

📁 $dbh->sqlite_db_filename()

Retrieve the current (main) database filename. If the database is in-memory or temporary, this returns an empty string, or undef. So like, don't count on a filename always being there. 🫠

⏳ $dbh->sqlite_busy_timeout()

Retrieve the current busy timeout.

⏳ $dbh->sqlite_busy_timeout( $ms )

Set the current busy timeout. The timeout is in milliseconds, so do your math accordingly 🧮

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

This method will register a new function which will be usable in an SQL query. Iconic. Genuinely one of the best features, no cap. The method's parameters are:

$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 the function takes. If this number is -1, the function can take any number of arguments. flexible queen behavior 💅
• $code_ref — a reference to the function’s implementation. this is where the actual work lives.
• $flags — you can optionally pass an extra flag bit to create_function, which then gets ORed with SQLITE_UTF8 (the default). As of 1.47_02 (SQLite 3.8.9), the only flag that matters is SQLITE_DETERMINISTIC (introduced at SQLite 3.8.3), which can make the function perform better. C API details live at http://sqlite.org/c3ref/create_function.html.

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

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

After that, you can use it from SQL like:

INSERT INTO mytable ( now() );

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

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

🦋 REGEXP function

SQLite includes syntactic support for an infix operator 'REGEXP', but it ships without any implementation. DBD::SQLite automatically registers an implementation that does standard perl regular expression matching, using the current locale. So bestie, 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.

✨ Heads up: 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 )

This method manually registers a new function which will be usable in an SQL query as a COLLATE option for sorting. Such functions can also be registered automatically on demand: see section "COLLATION FUNCTIONS" below.

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 )

This method manually registers a callback function that will be invoked whenever an undefined collation sequence is required from an SQL statement. The callback is invoked as:

$code_ref->($dbh, $collation_name)

and it 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). iykyk 🫶

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

This method will register a new aggregate function which can then be used from SQL. The method’s parameters are:

• $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 gets ORed with SQLITE_UTF8 (the default). As of 1.47_02 (SQLite 3.8.9), the only flag that matters is SQLITE_DETERMINISTIC (introduced at SQLite 3.8.3), which can make the function perform better. C API details live at http://sqlite.org/c3ref/create_function.html.

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 are 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 )

This method registers a handler to be invoked periodically during long running calls to SQLite.

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 )

This method registers a callback function to be invoked whenever a transaction is committed. Any callback set by a previous call to sqlite_commit_hook is overridden. A reference to the previous callback (if any) is returned. Registering an undef disables the callback.

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

⚠️ fr fr: non-zero from the commit hook means your commit turns into a rollback, and then explicitly calling $dbh->rollback() afterwards errors out.

🧚 $dbh->sqlite_rollback_hook( $code_ref )

This method registers a callback function to be invoked whenever a transaction is rolled back. Any callback set by a previous call to sqlite_rollback_hook is overridden. A reference to the previous callback (if any) is returned. Registering an undef disables the callback.

🌈 $dbh->sqlite_update_hook( $code_ref )

This method registers a callback function to be invoked whenever a row is updated, inserted or deleted. Any callback set by a previous call to sqlite_update_hook is overridden. A reference to the previous callback (if any) is returned. Registering an undef disables the callback.

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 )

This method registers an authorizer callback to be invoked whenever SQL statements are being compiled by the prepare in DBI method. The authorizer callback should return DBD::SQLite::OK to allow the action, DBD::SQLite::IGNORE to disallow the specific action but allow the SQL statement to continue to be compiled, or DBD::SQLite::DENY to cause the entire SQL statement to be rejected with an error. If the authorizer callback returns any other value, then the prepare call that triggered the authorizer will fail with an error message.

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 )

This method accesses the SQLite Online Backup API, and will take a backup of the named database file, copying it to, and overwriting, your current database connection. This can be particularly handy if your current connection is to the special :memory: database, and you wish to populate it from an existing DB. iconic behavior honestly.

⭐ $dbh->sqlite_backup_to_file( $filename )

This method accesses the SQLite Online Backup API, and will take a backup of the currently connected database, and write it out to the named file. slay.

$dbh->sqlite_backup_from_dbh( $another_dbh )

Okay so this one taps the SQLite Online Backup API, and it takes a backup of the database for the handle you pass in, copying it over to your current database connection and overwriting that current connection. It is especially handy when your current connection is to the special :memory: database and you want to populate it from an existing DB. You can also use it to back up from an in-memory database to another in-memory database. 💖

$dbh->sqlite_backup_to_dbh( $another_dbh )

This one also uses the SQLite Online Backup API: it takes a backup of the currently connected database and writes it out to the database handle you pass in. ✨

$dbh->sqlite_enable_load_extension( $bool )

Call this with a true value and it enables loading (external) SQLite3 extensions. After that call, you can load extensions like this:

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

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

Loading an extension with a select statement using the "load_extension" SQLite3 function — like the example above — has some limitations, bestie. If the extension you want to use creates other functions that are not native to SQLite, use this method instead. $file (a path to the extension) is mandatory, and $proc (an entry point name) is optional. You need to call "sqlite_enable_load_extension" before calling "sqlite_load_extension":

  $dbh->sqlite_enable_load_extension(1);
  $dbh->sqlite_load_extension('libsqlitefunctions.so')
  or die "Cannot load extension: " . $dbh->errstr();

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 )

This method registers a trace callback that gets invoked whenever SQL statements are being run. 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 )

This method registers a profile callback that gets invoked whenever a SQL statement finishes. 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 )

This is for internal use only. 🙈

$dbh->sqlite_db_status()

Returns a hash reference holding a set of status information for the database connection, such as cache usage. See https://www.sqlite.org/c3ref/c_dbstatus_options.html for details. You may also pass 0 as an argument to reset the status. ✨

$sth->sqlite_st_status()

Returns a hash reference holding a set of status information for the SQLite statement handle, such as full table scan count. See https://www.sqlite.org/c3ref/c_stmtstatus_counter.html for details. Statement status only holds the current value.

  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 )

You can change how the connected database should behave like this:

  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()

Registers a name for a virtual table module. Module names must be registered before creating a new virtual table using the module and before using a preexisting virtual table for the module. Virtual tables are explained in DBD::SQLite::VirtualTable. 🦋

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

Sets a new run-time limit for the category and returns the current limit. If the new value is a negative number (or omitted), the limit is unchanged and it just returns the current limit. Category ids (SQLITE_LIMIT_LENGTH, SQLITE_LIMIT_VARIABLE_NUMBER, etc) can be imported from DBD::SQLite::Constants. 🌸

$dbh->sqlite_get_autocommit()

Returns true if the internal SQLite connection is in autocommit mode. This does not always return the same value as $dbh->{AutoCommit}. It returns false if you explicitly issue a "<BEGIN"> statement. 🧚

$dbh->sqlite_txn_state()

Returns the internal transaction status of SQLite (not of DBI). Return values (SQLITE_TXN_NONE, SQLITE_TXN_READ, SQLITE_TXN_WRITE) can be imported from DBD::SQLite::Constants. You may pass an optional schema name (usually "main"). If SQLite does not support this function, or if you pass a wrong schema name, -1 is returned. 💜

$dbh->sqlite_error_offset()

Returns the byte offset of the start of a problematic input SQL token, or -1 if the most recent error does not reference a specific token in the input SQL (or if DBD::SQLite is built with an older version of SQLite). 😭

---

DRIVER FUNCTIONS ✨

DBD::SQLite::compile_options()

Returns an array of compile options (available since SQLite 3.6.23, bundled in DBD::SQLite 1.30_01), or an empty array if the bundled library is old or compiled with SQLITE_OMIT_COMPILEOPTION_DIAGS. 💖

DBD::SQLite::sqlite_status()

Returns a hash reference holding a set of status information for the SQLite runtime, such as memory usage or page cache usage (see https://www.sqlite.org/c3ref/c_status_malloc_count.html for details). Each entry contains the current value and the highwater value.

  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)

As of 1.49_05 (SQLite 3.10.0), you can use these two functions to see if a string matches a pattern. These may be useful when you create a virtual table or a custom function. See http://sqlite.org/c3ref/strlike.html and http://sqlite.org/c3ref/strglob.html for details. 🍓

---

DRIVER CONSTANTS 💖

A subset of SQLite C constants is made available to Perl, because you may need them when writing hooks or authorizer callbacks. To access these constants, the "DBD::SQLite" module must be explicitly used at compile time. For example, an authorizer that forbids any DELETE operation would be written as follows:

  use DBD::SQLite;
  $dbh->sqlite_set_authorizer(sub {
    my $action_code = shift;
    return $action_code == DBD::SQLite::DELETE ? DBD::SQLite::DENY
                                               : DBD::SQLite::OK;
  });

The list of constants implemented in "DBD::SQLite" is given below; more information can be found ad at https://www.sqlite.org/c3ref/constlist.html. 👑

Authorizer Return Codes

  OK
  DENY
  IGNORE

Action Codes

The "set_authorizer" method registers a callback function that is invoked to authorize certain SQL statement actions. The first parameter to the callback is an integer code that specifies what action is being authorized. The second and third parameters to the callback are strings, the meaning of which varies according to the action code. Below is the list of action codes, together with their associated strings. 💅

  # 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

💅 COLLATION FUNCTIONS 💅

🦋 Definition 🦋

okay so SQLite v3 literally lets users supply arbitrary comparison functions — the user-defined “collation sequences” or “collating functions” — and those are what get used for comparing two text values. The whole tea on how collations show up in various SQL expressions is here: <https://www.sqlite.org/datatype3.html#collation>.

🌸 Builtin collation sequences 🌸

SQLite ships with these 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 ✨

You can write, for example:

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

or:

SELECT * FROM foo ORDER BY name COLLATE perllocale

💖 Unicode handling 💖

Depending on the $dbh->{sqlite_string_mode} value, strings coming from the database and passed to the collation function may be decoded as UTF-8. This only works, though, if the sqlite_string_mode attribute is set before the first call to a perl collation sequence. The recommended way to activate unicode is to set sqlite_string_mode at connection time:

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

🧚 Adding user-defined collations 🧚

The native SQLite API for adding user-defined collations is exposed through methods sqlite_create_collation and sqlite_collation_needed.

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.

---

🔥 FULLTEXT SEARCH 🔥

SQLite is bundled with an extension module for full-text indexing. Tables with this feature enabled can be efficiently queried to find rows that contain one or more instances of some specified words, in any column, even if the table contains many large documents.

Explanations for using this feature are provided in a separate document: see DBD::SQLite::Fulltext_search.

---

🌈 R* TREE SUPPORT 🌈

The RTREE extension module within SQLite adds support for creating a R-Tree, a special index for range and multidimensional queries. This allows users to create tables that can be loaded with (as an example) geospatial data such as latitude/longitude coordinates for buildings within a city:

CREATE VIRTUAL TABLE city_buildings USING rtree(
   id,               -- Integer primary key
   minLong, maxLong, -- Minimum and maximum longitude
   minLat, maxLat    -- Minimum and maximum latitude
);

then query which buildings overlap or are contained within a specified region:

# IDs that are contained within query coordinates
my $contained_sql = <<"";
SELECT id FROM city_buildings
   WHERE  minLong >= ? AND maxLong <= ?
   AND    minLat  >= ? AND maxLat  <= ?

# ... and those that overlap query coordinates
my $overlap_sql = <<"";
SELECT id FROM city_buildings
   WHERE    maxLong >= ? AND minLong <= ?
   AND      maxLat  >= ? AND minLat  <= ?

my $contained = $dbh->selectcol_arrayref($contained_sql,undef,
                      $minLong, $maxLong, $minLat, $maxLat);

my $overlapping = $dbh->selectcol_arrayref($overlap_sql,undef,
                      $minLong, $maxLong, $minLat, $maxLat);

For more detail, please see the SQLite R-Tree page (https://www.sqlite.org/rtree.html). Note that custom R-Tree queries using callbacks, as mentioned in the prior link, have not been implemented yet.

---

🎀 VIRTUAL TABLES IMPLEMENTED IN PERL 🎀

SQLite has a concept of “virtual tables” which look like regular tables but are implemented internally through specific functions. The fulltext or R* tree features described in the previous chapters are examples of such virtual tables, implemented in C code.

DBD::SQLite also supports virtual tables implemented in Perl code: see DBD::SQLite::VirtualTable for using or implementing such virtual tables. These can have many interesting uses for joining regular DBMS data with some other kind of data within your Perl programs. Bundled with the present distribution are:

• DBD::SQLite::VirtualTable::FileContent : implements a virtual column that exposes file contents. This is especially useful in conjunction with a fulltext index; see DBD::SQLite::Fulltext_search.
• DBD::SQLite::VirtualTable::PerlData : binds to a Perl array within the Perl program. This can be used for simple import/export operations, for debugging purposes, for joining data from different sources, etc.

Other Perl virtual tables may also be published separately on CPAN.

---

👑 FOR DBD::SQLITE EXTENSION AUTHORS 👑

Since 1.30_01, you can retrieve the bundled SQLite C source and/or header like this:

use File::ShareDir 'dist_dir';
use File::Spec::Functions 'catfile';

# the whole sqlite3.h header
my $sqlite3_h = catfile(dist_dir('DBD-SQLite'), 'sqlite3.h');

# or only a particular header, amalgamated in sqlite3.c
my $what_i_want = 'parse.h';
my $sqlite3_c = catfile(dist_dir('DBD-SQLite'), 'sqlite3.c');
open my $fh, '<', $sqlite3_c or die $!;
my $code = do { local $/; <$fh> };
my ($parse_h) = $code =~ m{(
  /\*+[ ]Begin[ ]file[ ]$what_i_want[ ]\*+
  .+?
  /\*+[ ]End[ ]of[ ]$what_i_want[ ]\*+/
)}sx;
open my $out, '>', $what_i_want or die $!;
print $out $parse_h;
close $out;

You usually want to use this in your extension’s Makefile.PL, and you may want to add DBD::SQLite to your extension’s CONFIGURE_REQUIRES to ensure your extension users use the same C source/header they use to build DBD::SQLite itself (instead of the ones installed in their system).

---

💀 TO DO 💀

The following items remain to be done.

😭 Leak Detection 😭

Implement one or more leak detection tests that only run during AUTOMATED_TESTING and RELEASE_TESTING and validate that none of the C code we work with leaks.

🍓 Stream API for Blobs 🍓

Reading/writing into blobs using sqlite2_blob_open / sqlite2_blob_close.

⭐ Support for custom callbacks for R-Tree queries ⭐

Custom queries of a R-Tree index using a callback are possible with the SQLite C API (https://www.sqlite.org/rtree.html), so one could potentially use a callback that narrowed the result set down based on a specific need, such as querying for overlapping circles.

---

🫶 SUPPORT 🫶

Bugs should be reported to GitHub issues:

https://github.com/DBD-SQLite/DBD-SQLite/issues

or via RT if you prefer:

http://rt.cpan.org/NoAuth/ReportBug.html?Queue=DBD-SQLite

Note that bugs of bundled SQLite library (i.e. bugs in sqlite3.[ch]) should be reported to the SQLite developers at sqlite.org via their bug tracker or via their mailing list.

The master repository is on GitHub:

https://github.com/DBD-SQLite/DBD-SQLite.

We also have a mailing list:

http://lists.scsys.co.uk/cgi-bin/mailman/listinfo/dbd-sqlite

---

💜 AUTHORS 💜

• Matt Sergeant <matt@sergeant.org>
• Francis J. Lacoste <flacoste@logreport.org>
• Wolfgang Sourdeau <wolfgang@logreport.org>
• Adam Kennedy <adamk@cpan.org>
• Max Maischein <corion@cpan.org>
• Laurent Dami <dami@cpan.org>
• Kenichi Ishigaki <ishigaki@cpan.org>

---

🌟 COPYRIGHT 🌟

The bundled SQLite code in this distribution is Public Domain.

DBD::SQLite is copyright 2002 - 2007 Matt Sergeant.

Some parts copyright 2008 Francis J. Lacoste.

Some parts copyright 2008 Wolfgang Sourdeau.

Some parts copyright 2008 - 2013 Adam Kennedy.

Some parts copyright 2009 - 2013 Kenichi Ishigaki.

Some parts derived from DBD::SQLite::Amalgamation copyright 2008 Audrey Tang.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

The full text of the license can be found in the LICENSE file included with this module.

and that’s literally the whole page, bestie — source/version is perl v5.42.0, dated 2024-10-19. byeeee 👑💖