.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings. \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote. \*(C+ will
.\" give a nicer C++. Capital omega is used to do unbreakable dashes and
.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff,
.\" nothing in troff, for use with C<>.
.tr \(*W-
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
. ds -- \(*W-
. ds PI pi
. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
. ds L" ""
. ds R" ""
. ds C` ""
. ds C' ""
'br\}
.el\{\
. ds -- \|\(em\|
. ds PI \(*p
. ds L" ``
. ds R" ''
'br\}
.\"
.\" Escape single quotes in literal strings from groff's Unicode transform.
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
.\" entries marked with X<> in POD. Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.ie \nF \{\
. de IX
. tm Index:\\$1\t\\n%\t"\\$2"
..
. nr % 0
. rr F
.\}
.el \{\
. de IX
..
.\}
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear. Run. Save yourself. No user-serviceable parts.
. \" fudge factors for nroff and troff
.if n \{\
. ds #H 0
. ds #V .8m
. ds #F .3m
. ds #[ \f1
. ds #] \fP
.\}
.if t \{\
. ds #H ((1u-(\\\\n(.fu%2u))*.13m)
. ds #V .6m
. ds #F 0
. ds #[ \&
. ds #] \&
.\}
. \" simple accents for nroff and troff
.if n \{\
. ds ' \&
. ds ` \&
. ds ^ \&
. ds , \&
. ds ~ ~
. ds /
.\}
.if t \{\
. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
. \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
. \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
. \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
. ds : e
. ds 8 ss
. ds o a
. ds d- d\h'-1'\(ga
. ds D- D\h'-1'\(hy
. ds th \o'bp'
. ds Th \o'LP'
. ds ae ae
. ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "DBD::SQLite 3pm"
.TH DBD::SQLite 3pm "2012-06-09" "perl v5.14.2" "User Contributed Perl Documentation"
.\" For nroff, turn off justification. Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.if n .ad l
.nh
.SH "NAME"
DBD::SQLite \- Self\-contained RDBMS in a DBI Driver
.SH "SYNOPSIS"
.IX Header "SYNOPSIS"
.Vb 2
\& use DBI;
\& my $dbh = DBI\->connect("dbi:SQLite:dbname=$dbfile","","");
.Ve
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
SQLite is a public domain file-based relational database engine that
you can find at .
.PP
\&\fBDBD::SQLite\fR is a Perl \s-1DBI\s0 driver for SQLite, that includes
the entire thing in the distribution.
So in order to get a fast transaction capable \s-1RDBMS\s0 working for your
perl project you simply have to install this module, and \fBnothing\fR
else.
.PP
SQLite supports the following features:
.IP "Implements a large subset of \s-1SQL92\s0" 4
.IX Item "Implements a large subset of SQL92"
See for details.
.IP "A complete \s-1DB\s0 in a single disk file" 4
.IX Item "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 \s-1DBD::CSV\s0.
.IP "Atomic commit and rollback" 4
.IX Item "Atomic commit and rollback"
Yes, \fBDBD::SQLite\fR is small and light, but it supports full transactions!
.IP "Extensible" 4
.IX Item "Extensible"
User-defined aggregate or regular functions can be registered with the
\&\s-1SQL\s0 parser.
.PP
There's lots more to it, so please refer to the docs on the SQLite web
page, listed above, for \s-1SQL\s0 details. Also refer to \s-1DBI\s0 for details
on how to use \s-1DBI\s0 itself. The \s-1API\s0 works like every \s-1DBI\s0 module does.
However, currently many statement attributes are not implemented or
are limited by the typeless nature of the SQLite database.
.SH "NOTABLE DIFFERENCES FROM OTHER DRIVERS"
.IX Header "NOTABLE DIFFERENCES FROM OTHER DRIVERS"
.SS "Database Name Is A File Name"
.IX Subsection "Database Name Is A File Name"
SQLite creates a file per a database. You should pass the \f(CW\*(C`path\*(C'\fR of
the database file (with or without a parent directory) in the \s-1DBI\s0
connection string (as a database \f(CW\*(C`name\*(C'\fR):
.PP
.Vb 1
\& my $dbh = DBI\->connect("dbi:SQLite:dbname=$dbfile","","");
.Ve
.PP
The file is opened in read/write mode, and will be created if
it does not exist yet.
.PP
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.
.PP
If the filename \f(CW$dbfile\fR is \*(L":memory:\*(R", 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.
.PP
Note that future versions of SQLite might make use of additional
special filenames that begin with the \*(L":\*(R" character. It is recommended
that when a database filename actually does begin with a \*(L":\*(R" character
you should prefix the filename with a pathname such as \*(L"./\*(R" to avoid
ambiguity.
.PP
If the filename \f(CW$dbfile\fR 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.
.SS "Accessing A Database With Other Tools"
.IX Subsection "Accessing A Database With Other Tools"
To access the database from the command line, try using \f(CW\*(C`dbish\*(C'\fR
which comes with the DBI::Shell module. Just type:
.PP
.Vb 1
\& dbish dbi:SQLite:foo.db
.Ve
.PP
On the command line to access the file \fIfoo.db\fR.
.PP
Alternatively you can install SQLite from the link above without
conflicting with \fBDBD::SQLite\fR and use the supplied \f(CW\*(C`sqlite3\*(C'\fR
command line tool.
.SS "Blobs"
.IX Subsection "Blobs"
As of version 1.11, blobs should \*(L"just work\*(R" in SQLite as text columns.
However this will cause the data to be treated as a string, so \s-1SQL\s0
statements such as length(x) will return the length of the column as a \s-1NUL\s0
terminated string, rather than the size of the blob in bytes. In order to
store natively as a \s-1BLOB\s0 use the following code:
.PP
.Vb 2
\& 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();
.Ve
.PP
And then retrieval just works:
.PP
.Vb 4
\& $sth = $dbh\->prepare("SELECT * FROM mytable WHERE id = 1");
\& $sth\->execute();
\& my $row = $sth\->fetch;
\& my $blobo = $row\->[1];
\&
\& # now $blobo == $blob
.Ve
.SS "Functions And Bind Parameters"
.IX Subsection "Functions And Bind Parameters"
As of this writing, a \s-1SQL\s0 that compares a return value of a function
with a numeric bind value like this doesn't work as you might expect.
.PP
.Vb 4
\& my $sth = $dbh\->prepare(q{
\& SELECT bar FROM foo GROUP BY bar HAVING count(*) > ?;
\& });
\& $sth\->execute(5);
.Ve
.PP
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:
.PP
.Vb 1
\& SELECT bar FROM foo GROUP BY bar HAVING count(*) > "5";
.Ve
.PP
There are three workarounds for this.
.IP "Use \fIbind_param()\fR explicitly" 4
.IX Item "Use bind_param() explicitly"
As shown above in the \f(CW\*(C`BLOB\*(C'\fR section, you can always use
\&\f(CW\*(C`bind_param()\*(C'\fR to tell the type of a bind value.
.Sp
.Vb 1
\& use DBI qw(:sql_types); # Don\*(Aqt 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();
.Ve
.IP "Add zero to make it a number" 4
.IX Item "Add zero to make it a number"
This is somewhat weird, but works anyway.
.Sp
.Vb 4
\& my $sth = $dbh\->prepare(q{
\& SELECT bar FROM foo GROUP BY bar HAVING count(*) > (? + 0);
\& });
\& $sth\->execute(5);
.Ve
.ie n .IP "Set ""sqlite_see_if_its_a_number"" database handle attribute" 4
.el .IP "Set \f(CWsqlite_see_if_its_a_number\fR database handle attribute" 4
.IX Item "Set sqlite_see_if_its_a_number database handle attribute"
As of version 1.32_02, you can use \f(CW\*(C`sqlite_see_if_its_a_number\*(C'\fR
to let DBD::SQLite to see if the bind values are numbers or not.
.Sp
.Vb 5
\& $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);
.Ve
.Sp
You can set it to true when you connect to a database.
.Sp
.Vb 5
\& my $dbh = DBI\->connect(\*(Aqdbi:SQLite:foo\*(Aq, undef, undef, {
\& AutoCommit => 1,
\& RaiseError => 1,
\& sqlite_see_if_its_a_number => 1,
\& });
.Ve
.Sp
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 \f(CW\*(C`sqlite3\*(C'\fR
command line tool, this attribute would help you.
.SS "Placeholders"
.IX Subsection "Placeholders"
SQLite supports several placeholder expressions, including \f(CW\*(C`?\*(C'\fR
and \f(CW\*(C`:AAAA\*(C'\fR. Consult the \s-1DBI\s0 and sqlite documentation for
details.
.PP
.PP
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.
.PP
.Vb 4
\& my $sth = $dbh\->prepare(
\& \*(Aqupdate TABLE set a=?1 where b=?2 and a IS NOT ?1\*(Aq
\& );
\& $sth\->execute(1, 2);
.Ve
.SS "Foreign Keys"
.IX Subsection "Foreign Keys"
\&\fB\s-1BE\s0 \s-1PREPARED\s0! \s-1WOLVES\s0 \s-1APPROACH\s0!!\fR
.PP
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 pragma actually to enable this feature and enforce the constraints.
.PP
To do this, issue the following pragma (see below), preferably as
soon as you connect to a database and you're not in a transaction:
.PP
.Vb 1
\& $dbh\->do("PRAGMA foreign_keys = ON");
.Ve
.PP
And you can explicitly disable the feature whenever you like by
turning the pragma off:
.PP
.Vb 1
\& $dbh\->do("PRAGMA foreign_keys = OFF");
.Ve
.PP
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 \fBplease do extensive testing to ensure
that your applications will continue to work when the foreign keys
support is enabled by default\fR. It is very likely that the sqlite
team will turn it default-on in the future, and we plan to do it
\&\s-1NO\s0 \s-1LATER\s0 \s-1THAN\s0 they do so.
.PP
See for details.
.SS "Pragma"
.IX Subsection "Pragma"
SQLite has a set of \*(L"Pragma\*(R"s to modifiy its operation or to query
for its internal data. These are specific to SQLite and are not
likely to work with other \s-1DBD\s0 libraries, but you may find some of
these are quite useful. DBD::SQLite actually sets some (like
\&\f(CW\*(C`show_datatypes\*(C'\fR) for you when you connect to a database.
See for details.
.SS "Transactions"
.IX Subsection "Transactions"
DBI/DBD::SQLite's transactions may be a bit confusing. They behave
differently according to the status of the \f(CW\*(C`AutoCommit\*(C'\fR flag:
.IP "When the AutoCommit flag is on" 4
.IX Item "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 \f(CW\*(C`begin_work\*(C'\fR method, or issue a \f(CW\*(C`BEGIN\*(C'\fR
statement. To end it, call \f(CW\*(C`commit/rollback\*(C'\fR methods, or issue
the corresponding statements.
.Sp
.Vb 1
\& $dbh\->{AutoCommit} = 1;
\&
\& $dbh\->begin_work; # or $dbh\->do(\*(AqBEGIN TRANSACTION\*(Aq);
\&
\& # $dbh\->{AutoCommit} is turned off temporarily during a transaction;
\&
\& $dbh\->commit; # or $dbh\->do(\*(AqCOMMIT\*(Aq);
\&
\& # $dbh\->{AutoCommit} is turned on again;
.Ve
.IP "When the AutoCommit flag is off" 4
.IX Item "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 \f(CW\*(C`BEGIN\*(C'\fR statement (only when an actual transaction has not
begun yet) but you're not allowed to call \f(CW\*(C`begin_work\*(C'\fR method
(if you don't issue a \f(CW\*(C`BEGIN\*(C'\fR, it will be issued internally).
You can commit or roll it back freely. Another transaction will
automatically begins if you execute another statement.
.Sp
.Vb 1
\& $dbh\->{AutoCommit} = 0;
\&
\& # $dbh\->do(\*(AqBEGIN TRANSACTION\*(Aq) is not necessary, but possible
\&
\& ...
\&
\& $dbh\->commit; # or $dbh\->do(\*(AqCOMMIT\*(Aq);
\&
\& # $dbh\->{AutoCommit} stays intact;
\&
\& $dbh\->{AutoCommit} = 1; # ends the transactional mode
.Ve
.PP
This \f(CW\*(C`AutoCommit\*(C'\fR mode is independent from the autocommit mode
of the internal SQLite library, which always begins by a \f(CW\*(C`BEGIN\*(C'\fR
statement, and ends by a \f(CW\*(C`COMMIT\*(C'\fR or a <\s-1ROLLBACK\s0>.
.SS "Transaction and Database Locking"
.IX Subsection "Transaction and Database Locking"
Transaction by \f(CW\*(C`AutoCommit\*(C'\fR or \f(CW\*(C`begin_work\*(C'\fR is nice and handy, but
sometimes you may get an annoying \*(L"database is locked\*(R" error.
This typically happens when someone begins a transaction, and tries
to write to a database while other person is reading from the
database (in another transaction). You might be surprised but SQLite
doesn't lock a database when you just begin a normal (deferred)
transaction to maximize concurrency. It reserves a lock when you
issue a statement to write, but until you actually try to write
with a \f(CW\*(C`commit\*(C'\fR statement, it allows other people to read from
the database. However, reading from the database also requires
\&\f(CW\*(C`shared lock\*(C'\fR, and that prevents to give you the \f(CW\*(C`exclusive lock\*(C'\fR
you reserved, thus you get the \*(L"database is locked\*(R" error, and
other people will get the same error if they try to write afterwards,
as you still have a \f(CW\*(C`pending\*(C'\fR lock. \f(CW\*(C`busy_timeout\*(C'\fR doesn't help
in this case.
.PP
To avoid this, set a transaction type explicitly. You can issue a
\&\f(CW\*(C`begin immediate transaction\*(C'\fR (or \f(CW\*(C`begin exclusive transaction\*(C'\fR)
for each transaction, or set \f(CW\*(C`sqlite_use_immediate_transaction\*(C'\fR
database handle attribute to true (since 1.30_02) to always use
an immediate transaction (even when you simply use \f(CW\*(C`begin_work\*(C'\fR
or turn off the \f(CW\*(C`AutoCommit\*(C'\fR.).
.PP
.Vb 3
\& my $dbh = DBI\->connect("dbi:SQLite::memory:", "", "", {
\& sqlite_use_immediate_transaction => 1,
\& });
.Ve
.PP
Note that this works only when all of the connections use the same
(non-deferred) transaction. See
for locking details.
.ie n .SS """$sth\->finish"" and Transaction Rollback"
.el .SS "\f(CW$sth\->finish\fP and Transaction Rollback"
.IX Subsection "$sth->finish and Transaction Rollback"
As the \s-1DBI\s0 doc says, you almost certainly do \fBnot\fR need to
call \*(L"finish\*(R" in \s-1DBI\s0 method if you fetch all rows (probably in a loop).
However, there are several exceptions to this rule, and rolling-back
of an unfinished \f(CW\*(C`SELECT\*(C'\fR statement is one of such exceptional
cases.
.PP
SQLite prohibits \f(CW\*(C`ROLLBACK\*(C'\fR of unfinished \f(CW\*(C`SELECT\*(C'\fR statements in
a transaction (See for
details). So you need to call \f(CW\*(C`finish\*(C'\fR before you issue a rollback.
.PP
.Vb 10
\& $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;
\& }
.Ve
.SS "Processing Multiple Statements At A Time"
.IX Subsection "Processing Multiple Statements At A Time"
\&\s-1DBI\s0's statement handle is not supposed to process multiple
statements at a time. So if you pass a string that contains multiple
statements (a \f(CW\*(C`dump\*(C'\fR) to a statement handle (via \f(CW\*(C`prepare\*(C'\fR or \f(CW\*(C`do\*(C'\fR),
DBD::SQLite only processes the first statement, and discards the
rest.
.PP
Since 1.30_01, you can retrieve those ignored (unprepared) statements
via \f(CW\*(C`$sth\->{sqlite_unprepared_statements}\*(C'\fR. It usually contains
nothing but white spaces, but if you really care, you can check this
attribute to see if there's anything left undone. Also, if you set
a \f(CW\*(C`sqlite_allow_multiple_statements\*(C'\fR attribute of a database handle
to true when you connect to a database, \f(CW\*(C`do\*(C'\fR method automatically
checks the \f(CW\*(C`sqlite_unprepared_statements\*(C'\fR attribute, and if it finds
anything undone (even if what's left is just a single white space),
it repeats the process again, to the end.
.SS "Performance"
.IX Subsection "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.
.PP
Queries like count(*) and avg(bytes) took fractions of a second to
return, but what surprised him most of all was:
.PP
.Vb 5
\& SELECT url, count(*) as count
\& FROM access_log
\& GROUP BY url
\& ORDER BY count desc
\& LIMIT 20
.Ve
.PP
To discover the top 20 hit URLs on the site (),
and it returned within 2 seconds. He was seriously considering
switching his log analysis code to use this little speed demon!
.PP
Oh yeah, and that was with no indexes on the table, on a 400MHz \s-1PIII\s0.
.PP
For best performance be sure to tune your hdparm settings if you
are using linux. Also you might want to set:
.PP
.Vb 1
\& PRAGMA synchronous = OFF
.Ve
.PP
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.
.PP
The memory usage of SQLite can also be tuned using the cache_size
pragma.
.PP
.Vb 1
\& $dbh\->do("PRAGMA cache_size = 800000");
.Ve
.PP
The above will allocate 800M for \s-1DB\s0 cache; the default is 2M.
Your sweet spot probably lies somewhere in between.
.SH "DRIVER PRIVATE ATTRIBUTES"
.IX Header "DRIVER PRIVATE ATTRIBUTES"
.SS "Database Handle Attributes"
.IX Subsection "Database Handle Attributes"
.IP "sqlite_version" 4
.IX Item "sqlite_version"
Returns the version of the SQLite library which \fBDBD::SQLite\fR is using,
e.g., \*(L"2.8.0\*(R". Can only be read.
.IP "sqlite_unicode" 4
.IX Item "sqlite_unicode"
If set to a true value, \fBDBD::SQLite\fR will turn the \s-1UTF\-8\s0 flag on for all
text strings coming out of the database (this feature is currently disabled
for perl < 5.8.5). For more details on the \s-1UTF\-8\s0 flag see
perlunicode. The default is for the \s-1UTF\-8\s0 flag to be turned off.
.Sp
Also note that due to some bizarreness in SQLite's type system (see
), if you want to retain
blob-style behavior for \fBsome\fR columns under \f(CW\*(C`$dbh\->{sqlite_unicode} = 1\*(C'\fR (say, to store images in the database), you have to state so
explicitly using the 3\-argument form of \*(L"bind_param\*(R" in \s-1DBI\s0 when doing
updates:
.Sp
.Vb 3
\& use DBI qw(:sql_types);
\& $dbh\->{sqlite_unicode} = 1;
\& my $sth = $dbh\->prepare("INSERT INTO mytable (blobcolumn) VALUES (?)");
\&
\& # Binary_data will be stored as is.
\& $sth\->bind_param(1, $binary_data, SQL_BLOB);
.Ve
.Sp
Defining the column type as \f(CW\*(C`BLOB\*(C'\fR in the \s-1DDL\s0 is \fBnot\fR sufficient.
.Sp
This attribute was originally named as \f(CW\*(C`unicode\*(C'\fR, and renamed to
\&\f(CW\*(C`sqlite_unicode\*(C'\fR for integrity since version 1.26_06. Old \f(CW\*(C`unicode\*(C'\fR
attribute is still accessible but will be deprecated in the near future.
.IP "sqlite_allow_multiple_statements" 4
.IX Item "sqlite_allow_multiple_statements"
If you set this to true, \f(CW\*(C`do\*(C'\fR method will process multiple
statements at one go. This may be handy, but with performance
penalty. See above for details.
.IP "sqlite_use_immediate_transaction" 4
.IX Item "sqlite_use_immediate_transaction"
If you set this to true, DBD::SQLite tries to issue a \f(CW\*(C`begin
immediate transaction\*(C'\fR (instead of \f(CW\*(C`begin transaction\*(C'\fR) when
necessary. See above for details.
.IP "sqlite_see_if_its_a_number" 4
.IX Item "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.
.SS "Statement Handle Attributes"
.IX Subsection "Statement Handle Attributes"
.IP "sqlite_unprepared_statements" 4
.IX Item "sqlite_unprepared_statements"
Returns an unprepared part of the statement you pass to \f(CW\*(C`prepare\*(C'\fR.
Typically this contains nothing but white spaces after a semicolon.
See above for details.
.SH "METHODS"
.IX Header "METHODS"
See also to the \s-1DBI\s0 documentation for the details of other common
methods.
.SS "table_info"
.IX Subsection "table_info"
.Vb 1
\& $sth = $dbh\->table_info(undef, $schema, $table, $type, \e%attr);
.Ve
.PP
Returns all tables and schemas (databases) as specified in \*(L"table_info\*(R" in \s-1DBI\s0.
The schema and table arguments will do a \f(CW\*(C`LIKE\*(C'\fR search. You can specify an
\&\s-1ESCAPE\s0 character by including an 'Escape' attribute in \e%attr. The \f(CW$type\fR
argument accepts a comma separated list of the following types '\s-1TABLE\s0',
\&'\s-1VIEW\s0', '\s-1LOCAL\s0 \s-1TEMPORARY\s0' and '\s-1SYSTEM\s0 \s-1TABLE\s0' (by default all are returned).
Note that a statement handle is returned, and not a direct list of tables.
.PP
The following fields are returned:
.PP
\&\fB\s-1TABLE_CAT\s0\fR: Always \s-1NULL\s0, as SQLite does not have the concept of catalogs.
.PP
\&\fB\s-1TABLE_SCHEM\s0\fR: 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.
.PP
\&\fB\s-1TABLE_NAME\s0\fR: The name of the table or view.
.PP
\&\fB\s-1TABLE_TYPE\s0\fR: The type of object returned. Will be one of '\s-1TABLE\s0', '\s-1VIEW\s0',
\&'\s-1LOCAL\s0 \s-1TEMPORARY\s0' or '\s-1SYSTEM\s0 \s-1TABLE\s0'.
.SS "primary_key, primary_key_info"
.IX Subsection "primary_key, primary_key_info"
.Vb 2
\& @names = $dbh\->primary_key(undef, $schema, $table);
\& $sth = $dbh\->primary_key_info(undef, $schema, $table, \e%attr);
.Ve
.PP
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 mothods is usually \f(CW\*(C`undef\*(C'\fR, and you'll usually
set \f(CW\*(C`undef\*(C'\fR for the second one (unless you want to know the primary
keys of temporary tables).
.SH "DRIVER PRIVATE METHODS"
.IX Header "DRIVER PRIVATE METHODS"
The following methods can be called via the \fIfunc()\fR method with a little
tweak, but the use of \fIfunc()\fR method is now discouraged by the \s-1DBI\s0 author
for various reasons (see \s-1DBI\s0's document
http://search.cpan.org/dist/DBI/lib/DBI/DBD.pm#\fIUsing_install_method()\fR_to_expose_driver\-private_methods
for details). So, if you're using \s-1DBI\s0 >= 1.608, use these \f(CW\*(C`sqlite_\*(C'\fR
methods. If you need to use an older \s-1DBI\s0, you can call these like this:
.PP
.Vb 1
\& $dbh\->func( ..., "(method name without sqlite_ prefix)" );
.Ve
.PP
Exception: \f(CW\*(C`sqlite_trace\*(C'\fR should always be called as is, even with \f(CW\*(C`func()\*(C'\fR
method (to avoid conflict with \s-1DBI\s0's \fItrace()\fR method).
.PP
.Vb 1
\& $dbh\->func( ..., "sqlite_trace");
.Ve
.ie n .SS "$dbh\->\fIsqlite_last_insert_rowid()\fP"
.el .SS "\f(CW$dbh\fP\->\fIsqlite_last_insert_rowid()\fP"
.IX Subsection "$dbh->sqlite_last_insert_rowid()"
This method returns the last inserted rowid. If you specify an \s-1INTEGER\s0 \s-1PRIMARY\s0
\&\s-1KEY\s0 as the first column in your table, that is the column that is returned.
Otherwise, it is the hidden \s-1ROWID\s0 column. See the sqlite docs for details.
.PP
Generally you should not be using this method. Use the \s-1DBI\s0 last_insert_id
method instead. The usage of this is:
.PP
.Vb 1
\& $h\->last_insert_id($catalog, $schema, $table_name, $field_name [, \e%attr ])
.Ve
.PP
Running \f(CW\*(C`$h\->last_insert_id("","","","")\*(C'\fR is the equivalent of running
\&\f(CW\*(C`$dbh\->sqlite_last_insert_rowid()\*(C'\fR directly.
.ie n .SS "$dbh\->\fIsqlite_busy_timeout()\fP"
.el .SS "\f(CW$dbh\fP\->\fIsqlite_busy_timeout()\fP"
.IX Subsection "$dbh->sqlite_busy_timeout()"
Retrieve the current busy timeout.
.ie n .SS "$dbh\->sqlite_busy_timeout( $ms )"
.el .SS "\f(CW$dbh\fP\->sqlite_busy_timeout( \f(CW$ms\fP )"
.IX Subsection "$dbh->sqlite_busy_timeout( $ms )"
Set the current busy timeout. The timeout is in milliseconds.
.ie n .SS "$dbh\->sqlite_create_function( $name, $argc, $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_create_function( \f(CW$name\fP, \f(CW$argc\fP, \f(CW$code_ref\fP )"
.IX Subsection "$dbh->sqlite_create_function( $name, $argc, $code_ref )"
This method will register a new function which will be usable in an \s-1SQL\s0
query. The method's parameters are:
.ie n .IP "$name" 4
.el .IP "\f(CW$name\fR" 4
.IX Item "$name"
The name of the function. This is the name of the function as it will
be used from \s-1SQL\s0.
.ie n .IP "$argc" 4
.el .IP "\f(CW$argc\fR" 4
.IX Item "$argc"
The number of arguments taken by the function. If this number is \-1,
the function can take any number of arguments.
.ie n .IP "$code_ref" 4
.el .IP "\f(CW$code_ref\fR" 4
.IX Item "$code_ref"
This should be a reference to the function's implementation.
.PP
For example, here is how to define a \fInow()\fR function which returns the
current number of seconds since the epoch:
.PP
.Vb 1
\& $dbh\->sqlite_create_function( \*(Aqnow\*(Aq, 0, sub { return time } );
.Ve
.PP
After this, it could be use from \s-1SQL\s0 as:
.PP
.Vb 1
\& INSERT INTO mytable ( now() );
.Ve
.PP
\fI\s-1REGEXP\s0 function\fR
.IX Subsection "REGEXP function"
.PP
SQLite includes syntactic support for an infix operator '\s-1REGEXP\s0', but
without any implementation. The \f(CW\*(C`DBD::SQLite\*(C'\fR 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
.PP
.Vb 1
\& SELECT * from table WHERE column REGEXP \*(Aq\ebA\ew+\*(Aq
.Ve
.PP
If you want case-insensitive searching, use perl regex flags, like this :
.PP
.Vb 1
\& SELECT * from table WHERE column REGEXP \*(Aq(?i:\ebA\ew+)\*(Aq
.Ve
.PP
The default \s-1REGEXP\s0 implementation can be overridden through the
\&\f(CW\*(C`create_function\*(C'\fR \s-1API\s0 described above.
.PP
Note that regexp matching will \fBnot\fR use SQLite indices, but will iterate
over all rows, so it could be quite costly in terms of performance.
.ie n .SS "$dbh\->sqlite_create_collation( $name, $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_create_collation( \f(CW$name\fP, \f(CW$code_ref\fP )"
.IX Subsection "$dbh->sqlite_create_collation( $name, $code_ref )"
This method manually registers a new function which will be usable in an \s-1SQL\s0
query as a \s-1COLLATE\s0 option for sorting. Such functions can also be registered
automatically on demand: see section \*(L"\s-1COLLATION\s0 \s-1FUNCTIONS\s0\*(R" below.
.PP
The method's parameters are:
.ie n .IP "$name" 4
.el .IP "\f(CW$name\fR" 4
.IX Item "$name"
The name of the function exposed to \s-1SQL\s0.
.ie n .IP "$code_ref" 4
.el .IP "\f(CW$code_ref\fR" 4
.IX Item "$code_ref"
Reference to the function's implementation.
The driver will check that this is a proper sorting function.
.ie n .SS "$dbh\->sqlite_collation_needed( $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_collation_needed( \f(CW$code_ref\fP )"
.IX Subsection "$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 \s-1SQL\s0 statement. The callback is invoked as
.PP
.Vb 1
\& $code_ref\->($dbh, $collation_name)
.Ve
.PP
and should register the desired collation using
\&\*(L"sqlite_create_collation\*(R".
.PP
An initial callback is already registered by \f(CW\*(C`DBD::SQLite\*(C'\fR,
so for most common cases it will be simpler to just
add your collation sequences in the \f(CW%DBD::SQLite::COLLATION\fR
hash (see section \*(L"\s-1COLLATION\s0 \s-1FUNCTIONS\s0\*(R" below).
.ie n .SS "$dbh\->sqlite_create_aggregate( $name, $argc, $pkg )"
.el .SS "\f(CW$dbh\fP\->sqlite_create_aggregate( \f(CW$name\fP, \f(CW$argc\fP, \f(CW$pkg\fP )"
.IX Subsection "$dbh->sqlite_create_aggregate( $name, $argc, $pkg )"
This method will register a new aggregate function which can then be used
from \s-1SQL\s0. The method's parameters are:
.ie n .IP "$name" 4
.el .IP "\f(CW$name\fR" 4
.IX Item "$name"
The name of the aggregate function, this is the name under which the
function will be available from \s-1SQL\s0.
.ie n .IP "$argc" 4
.el .IP "\f(CW$argc\fR" 4
.IX Item "$argc"
This is an integer which tells the \s-1SQL\s0 parser how many arguments the
function takes. If that number is \-1, the function can take any number
of arguments.
.ie n .IP "$pkg" 4
.el .IP "\f(CW$pkg\fR" 4
.IX Item "$pkg"
This is the package which implements the aggregator interface.
.PP
The aggregator interface consists of defining three methods:
.IP "\fInew()\fR" 4
.IX Item "new()"
This method will be called once to create an object which should
be used to aggregate the rows in a particular group. The \fIstep()\fR and
\&\fIfinalize()\fR methods will be called upon the reference return by
the method.
.IP "step(@_)" 4
.IX Item "step(@_)"
This method will be called once for each row in the aggregate.
.IP "\fIfinalize()\fR" 4
.IX Item "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, \fIfinalize()\fR will be called right
after \fInew()\fR.
.PP
Here is a simple aggregate function which returns the variance
(example adapted from pysqlite):
.PP
.Vb 1
\& 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 += ($x \- $mu)**2;
\& }
\& $sigma = $sigma / ($n \- 1);
\&
\& return $sigma;
\& }
\&
\& $dbh\->sqlite_create_aggregate( "variance", 1, \*(Aqvariance\*(Aq );
.Ve
.PP
The aggregate function can then be used as:
.PP
.Vb 3
\& SELECT group_name, variance(score)
\& FROM results
\& GROUP BY group_name;
.Ve
.PP
For more examples, see the DBD::SQLite::Cookbook.
.ie n .SS "$dbh\->sqlite_progress_handler( $n_opcodes, $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_progress_handler( \f(CW$n_opcodes\fP, \f(CW$code_ref\fP )"
.IX Subsection "$dbh->sqlite_progress_handler( $n_opcodes, $code_ref )"
This method registers a handler to be invoked periodically during long
running calls to SQLite.
.PP
An example use for this interface is to keep a \s-1GUI\s0 updated during a
large query. The parameters are:
.ie n .IP "$n_opcodes" 4
.el .IP "\f(CW$n_opcodes\fR" 4
.IX Item "$n_opcodes"
The progress handler is invoked once for every \f(CW$n_opcodes\fR
virtual machine opcodes in SQLite.
.ie n .IP "$code_ref" 4
.el .IP "\f(CW$code_ref\fR" 4
.IX Item "$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 \*(L"Cancel\*(R" button on a \s-1GUI\s0 dialog box.
.Sp
Set this argument to \f(CW\*(C`undef\*(C'\fR if you want to unregister a previous
progress handler.
.ie n .SS "$dbh\->sqlite_commit_hook( $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_commit_hook( \f(CW$code_ref\fP )"
.IX Subsection "$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
\&\f(CW\*(C`sqlite_commit_hook\*(C'\fR is overridden. A reference to the previous
callback (if any) is returned. Registering an \f(CW\*(C`undef\*(C'\fR disables the
callback.
.PP
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
\&\fIexplicitly\fR call \f(CW\*(C`$dbh\->rollback()\*(C'\fR afterwards would yield an
error).
.ie n .SS "$dbh\->sqlite_rollback_hook( $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_rollback_hook( \f(CW$code_ref\fP )"
.IX Subsection "$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
\&\f(CW\*(C`sqlite_rollback_hook\*(C'\fR is overridden. A reference to the previous
callback (if any) is returned. Registering an \f(CW\*(C`undef\*(C'\fR disables the
callback.
.ie n .SS "$dbh\->sqlite_update_hook( $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_update_hook( \f(CW$code_ref\fP )"
.IX Subsection "$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
\&\f(CW\*(C`sqlite_update_hook\*(C'\fR is overridden. A reference to the previous
callback (if any) is returned. Registering an \f(CW\*(C`undef\*(C'\fR disables the
callback.
.PP
The callback will be called as
.PP
.Vb 1
\& $code_ref\->($action_code, $database, $table, $rowid)
.Ve
.PP
where
.ie n .IP "$action_code" 4
.el .IP "\f(CW$action_code\fR" 4
.IX Item "$action_code"
is an integer equal to either \f(CW\*(C`DBD::SQLite::INSERT\*(C'\fR,
\&\f(CW\*(C`DBD::SQLite::DELETE\*(C'\fR or \f(CW\*(C`DBD::SQLite::UPDATE\*(C'\fR
(see \*(L"Action Codes\*(R");
.ie n .IP "$database" 4
.el .IP "\f(CW$database\fR" 4
.IX Item "$database"
is the name of the database containing the affected row;
.ie n .IP "$table" 4
.el .IP "\f(CW$table\fR" 4
.IX Item "$table"
is the name of the table containing the affected row;
.ie n .IP "$rowid" 4
.el .IP "\f(CW$rowid\fR" 4
.IX Item "$rowid"
is the unique 64\-bit signed integer key of the affected row within
that table.
.ie n .SS "$dbh\->sqlite_set_authorizer( $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_set_authorizer( \f(CW$code_ref\fP )"
.IX Subsection "$dbh->sqlite_set_authorizer( $code_ref )"
This method registers an authorizer callback to be invoked whenever
\&\s-1SQL\s0 statements are being compiled by the \*(L"prepare\*(R" in \s-1DBI\s0 method. The
authorizer callback should return \f(CW\*(C`DBD::SQLite::OK\*(C'\fR to allow the
action, \f(CW\*(C`DBD::SQLite::IGNORE\*(C'\fR to disallow the specific action but
allow the \s-1SQL\s0 statement to continue to be compiled, or
\&\f(CW\*(C`DBD::SQLite::DENY\*(C'\fR to cause the entire \s-1SQL\s0 statement to be rejected
with an error. If the authorizer callback returns any other value,
then then \f(CW\*(C`prepare\*(C'\fR call that triggered the authorizer will fail with
an error message.
.PP
An authorizer is used when preparing \s-1SQL\s0 statements from an untrusted
source, to ensure that the \s-1SQL\s0 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 \s-1SQL\s0 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 \s-1SQL\s0 is being
prepared that disallows everything except \s-1SELECT\s0 statements.
.PP
The callback will be called as
.PP
.Vb 1
\& $code_ref\->($action_code, $string1, $string2, $database, $trigger_or_view)
.Ve
.PP
where
.ie n .IP "$action_code" 4
.el .IP "\f(CW$action_code\fR" 4
.IX Item "$action_code"
is an integer that specifies what action is being authorized
(see \*(L"Action Codes\*(R").
.ie n .IP "$string1, $string2" 4
.el .IP "\f(CW$string1\fR, \f(CW$string2\fR" 4
.IX Item "$string1, $string2"
are strings that depend on the action code
(see \*(L"Action Codes\*(R").
.ie n .IP "$database" 4
.el .IP "\f(CW$database\fR" 4
.IX Item "$database"
is the name of the database (\f(CW\*(C`main\*(C'\fR, \f(CW\*(C`temp\*(C'\fR, etc.) if applicable.
.ie n .IP "$trigger_or_view" 4
.el .IP "\f(CW$trigger_or_view\fR" 4
.IX Item "$trigger_or_view"
is the name of the inner-most trigger or view that is responsible for
the access attempt, or \f(CW\*(C`undef\*(C'\fR if this access attempt is directly from
top-level \s-1SQL\s0 code.
.ie n .SS "$dbh\->sqlite_backup_from_file( $filename )"
.el .SS "\f(CW$dbh\fP\->sqlite_backup_from_file( \f(CW$filename\fP )"
.IX Subsection "$dbh->sqlite_backup_from_file( $filename )"
This method accesses the SQLite Online Backup \s-1API\s0, 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 \s-1DB\s0.
.ie n .SS "$dbh\->sqlite_backup_to_file( $filename )"
.el .SS "\f(CW$dbh\fP\->sqlite_backup_to_file( \f(CW$filename\fP )"
.IX Subsection "$dbh->sqlite_backup_to_file( $filename )"
This method accesses the SQLite Online Backup \s-1API\s0, and will take a backup of
the currently connected database, and write it out to the named file.
.ie n .SS "$dbh\->sqlite_enable_load_extension( $bool )"
.el .SS "\f(CW$dbh\fP\->sqlite_enable_load_extension( \f(CW$bool\fP )"
.IX Subsection "$dbh->sqlite_enable_load_extension( $bool )"
Calling this method with a true value enables loading (external)
sqlite3 extensions. After the call, you can load extensions like this:
.PP
.Vb 3
\& $dbh\->sqlite_enable_load_extension(1);
\& $sth = $dbh\->prepare("select load_extension(\*(Aqlibsqlitefunctions.so\*(Aq)")
\& or die "Cannot prepare: " . $dbh\->errstr();
.Ve
.ie n .SS "$dbh\->sqlite_trace( $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_trace( \f(CW$code_ref\fP )"
.IX Subsection "$dbh->sqlite_trace( $code_ref )"
This method registers a trace callback to be invoked whenever
\&\s-1SQL\s0 statements are being run.
.PP
The callback will be called as
.PP
.Vb 1
\& $code_ref\->($statement)
.Ve
.PP
where
.ie n .IP "$statement" 4
.el .IP "\f(CW$statement\fR" 4
.IX Item "$statement"
is a \s-1UTF\-8\s0 rendering of the \s-1SQL\s0 statement text as the statement
first begins executing.
.PP
Additional callbacks might occur as each triggered subprogram is
entered. The callbacks for triggers contain a \s-1UTF\-8\s0 \s-1SQL\s0 comment
that identifies the trigger.
.PP
See also \*(L"\s-1TRACING\s0\*(R" in \s-1DBI\s0 for better tracing options.
.ie n .SS "$dbh\->sqlite_profile( $code_ref )"
.el .SS "\f(CW$dbh\fP\->sqlite_profile( \f(CW$code_ref\fP )"
.IX Subsection "$dbh->sqlite_profile( $code_ref )"
This method registers a profile callback to be invoked whenever
a \s-1SQL\s0 statement finishes.
.PP
The callback will be called as
.PP
.Vb 1
\& $code_ref\->($statement, $elapsed_time)
.Ve
.PP
where
.ie n .IP "$statement" 4
.el .IP "\f(CW$statement\fR" 4
.IX Item "$statement"
is the original statement text (without bind parameters).
.ie n .IP "$elapsed_time" 4
.el .IP "\f(CW$elapsed_time\fR" 4
.IX Item "$elapsed_time"
is an estimate of wall-clock time of how long that statement took to run (in milliseconds).
.PP
This method is considered experimental and is subject to change in future versions of SQLite.
.PP
See also DBI::Profile for better profiling options.
.SS "\fIDBD::SQLite::compile_options()\fP"
.IX Subsection "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 \s-1SQLITE_OMIT_COMPILEOPTION_DIAGS\s0.
.SH "DRIVER CONSTANTS"
.IX Header "DRIVER CONSTANTS"
A subset of SQLite C constants are made available to Perl,
because they may be needed when writing
hooks or authorizer callbacks. For accessing such constants,
the \f(CW\*(C`DBD::SQLite\*(C'\fR module must be explicitly \f(CW\*(C`use\*(C'\fRd at compile
time. For example, an authorizer that forbids any
\&\s-1DELETE\s0 operation would be written as follows :
.PP
.Vb 6
\& use DBD::SQLite;
\& $dbh\->sqlite_set_authorizer(sub {
\& my $action_code = shift;
\& return $action_code == DBD::SQLite::DELETE ? DBD::SQLite::DENY
\& : DBD::SQLite::OK;
\& });
.Ve
.PP
The list of constants implemented in \f(CW\*(C`DBD::SQLite\*(C'\fR is given
below; more information can be found ad
at .
.SS "Authorizer Return Codes"
.IX Subsection "Authorizer Return Codes"
.Vb 3
\& OK
\& DENY
\& IGNORE
.Ve
.SS "Action Codes"
.IX Subsection "Action Codes"
The \*(L"set_authorizer\*(R" method registers a callback function that is
invoked to authorize certain \s-1SQL\s0 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.
.PP
.Vb 10
\& # 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
.Ve
.SH "COLLATION FUNCTIONS"
.IX Header "COLLATION FUNCTIONS"
.SS "Definition"
.IX Subsection "Definition"
SQLite v3 provides the ability for users to supply arbitrary
comparison functions, known as user-defined \*(L"collation sequences\*(R" or
\&\*(L"collating functions\*(R", to be used for comparing two text values.
explains how collations are used in various \s-1SQL\s0 expressions.
.SS "Builtin collation sequences"
.IX Subsection "Builtin collation sequences"
The following collation sequences are builtin within SQLite :
.IP "\fB\s-1BINARY\s0\fR" 4
.IX Item "BINARY"
Compares string data using \fImemcmp()\fR, regardless of text encoding.
.IP "\fB\s-1NOCASE\s0\fR" 4
.IX Item "NOCASE"
The same as binary, except the 26 upper case characters of \s-1ASCII\s0 are
folded to their lower case equivalents before the comparison is
performed. Note that only \s-1ASCII\s0 characters are case folded. SQLite
does not attempt to do full \s-1UTF\s0 case folding due to the size of the
tables required.
.IP "\fB\s-1RTRIM\s0\fR" 4
.IX Item "RTRIM"
The same as binary, except that trailing space characters are ignored.
.PP
In addition, \f(CW\*(C`DBD::SQLite\*(C'\fR automatically installs the
following collation sequences :
.IP "\fBperl\fR" 4
.IX Item "perl"
corresponds to the Perl \f(CW\*(C`cmp\*(C'\fR operator
.IP "\fBperllocale\fR" 4
.IX Item "perllocale"
Perl \f(CW\*(C`cmp\*(C'\fR operator, in a context where \f(CW\*(C`use locale\*(C'\fR is activated.
.SS "Usage"
.IX Subsection "Usage"
You can write for example
.PP
.Vb 5
\& CREATE TABLE foo(
\& txt1 COLLATE perl,
\& txt2 COLLATE perllocale,
\& txt3 COLLATE nocase
\& )
.Ve
.PP
or
.PP
.Vb 1
\& SELECT * FROM foo ORDER BY name COLLATE perllocale
.Ve
.SS "Unicode handling"
.IX Subsection "Unicode handling"
If the attribute \f(CW\*(C`$dbh\->{sqlite_unicode}\*(C'\fR is set, strings coming from
the database and passed to the collation function will be properly
tagged with the utf8 flag; but this only works if the
\&\f(CW\*(C`sqlite_unicode\*(C'\fR attribute is set \fBbefore\fR the first call to
a perl collation sequence . The recommended way to activate unicode
is to set the parameter at connection time :
.PP
.Vb 7
\& my $dbh = DBI\->connect(
\& "dbi:SQLite:dbname=foo", "", "",
\& {
\& RaiseError => 1,
\& sqlite_unicode => 1,
\& }
\& );
.Ve
.SS "Adding user-defined collations"
.IX Subsection "Adding user-defined collations"
The native SQLite \s-1API\s0 for adding user-defined collations is
exposed through methods \*(L"sqlite_create_collation\*(R" and
\&\*(L"sqlite_collation_needed\*(R".
.PP
To avoid calling these functions every time a \f(CW$dbh\fR handle is
created, \f(CW\*(C`DBD::SQLite\*(C'\fR offers a simpler interface through the
\&\f(CW%DBD::SQLite::COLLATION\fR hash : just insert your own
collation functions in that hash, and whenever an unknown
collation name is encountered in \s-1SQL\s0, 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 :
.PP
.Vb 10
\& use DBD::SQLite;
\& $DBD::SQLite::COLLATION{no_accents} = sub {
\& my ( $a, $b ) = map lc, @_;
\& tr[XXXXXXXXXXXXXXXXXXXXXXXXXXXX]
\& [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);
.Ve
.PP
The builtin \f(CW\*(C`perl\*(C'\fR or \f(CW\*(C`perllocale\*(C'\fR collations are predefined
in that same hash.
.PP
The \s-1COLLATION\s0 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 \*(L"write-only\*(R"
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 \f(CW\*(C`perl\*(C'\fR and \f(CW\*(C`perllocale\*(C'\fR).
.PP
If you really, really need to change or delete an entry, you can
always grab the tied object underneath \f(CW%DBD::SQLite::COLLATION\fR \-\-\-
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
\&\fIrequests\fR for collations. In other words, if you want to change
the behaviour of a collation within an existing \f(CW$dbh\fR, you
need to call the \*(L"create_collation\*(R" method directly.
.SH "FULLTEXT SEARCH"
.IX Header "FULLTEXT SEARCH"
The \s-1FTS3\s0 extension module within SQLite allows users to create special
tables with a built-in full-text index (hereafter \*(L"\s-1FTS3\s0 tables\*(R"). The
full-text index allows the user to efficiently query the database for
all rows that contain one or more instances of a specified word (hereafter
a \*(L"token\*(R"), even if the table contains many large documents.
.SS "Short introduction to \s-1FTS3\s0"
.IX Subsection "Short introduction to FTS3"
The detailed documentation for \s-1FTS3\s0 can be found
at . Here is a very short example :
.PP
.Vb 2
\& $dbh\->do(<<"") or die DBI::errstr;
\& CREATE VIRTUAL TABLE fts_example USING fts3(content)
\&
\& my $sth = $dbh\->prepare("INSERT INTO fts_example(content) VALUES (?))");
\& $sth\->execute($_) foreach @docs_to_insert;
\&
\& my $results = $dbh\->selectall_arrayref(<<"");
\& SELECT docid, snippet(content) FROM fts_example WHERE content MATCH \*(Aqfoo\*(Aq
.Ve
.PP
The key points in this example are :
.IP "\(bu" 4
The syntax for creating \s-1FTS3\s0 tables is
.Sp
.Vb 1
\& CREATE VIRTUAL TABLE USING fts3()
.Ve
.Sp
where \f(CW\*(C`\*(C'\fR is a list of column names. Columns may be
typed, but the type information is ignored. If no columns
are specified, the default is a single column named \f(CW\*(C`content\*(C'\fR.
In addition, \s-1FTS3\s0 tables have an implicit column called \f(CW\*(C`docid\*(C'\fR
(or also \f(CW\*(C`rowid\*(C'\fR) for numbering the stored documents.
.IP "\(bu" 4
Statements for inserting, updating or deleting records
use the same syntax as for regular SQLite tables.
.IP "\(bu" 4
Full-text searches are specified with the \f(CW\*(C`MATCH\*(C'\fR operator, and an
operand which may be a single word, a word prefix ending with '*', a
list of words, a \*(L"phrase query\*(R" in double quotes, or a boolean combination
of the above.
.IP "\(bu" 4
The builtin function \f(CW\*(C`snippet(...)\*(C'\fR builds a formatted excerpt of the
document text, where the words pertaining to the query are highlighted.
.PP
There are many more details to building and searching
\&\s-1FTS3\s0 tables, so we strongly invite you to read
the full documentation at at .
.PP
\&\fBIncompatible change\fR :
starting from version 1.31, \f(CW\*(C`DBD::SQLite\*(C'\fR uses the new, recommended
\&\*(L"Enhanced Query Syntax\*(R" for binary set operators (\s-1AND\s0, \s-1OR\s0, \s-1NOT\s0, possibly
nested with parenthesis). Previous versions of \f(CW\*(C`DBD::SQLite\*(C'\fR used the
\&\*(L"Standard Query Syntax\*(R" (see ).
Unfortunately this is a compilation switch, so it cannot be tuned
at runtime; however, since \s-1FTS3\s0 was never advertised in versions prior
to 1.31, the change should be invisible to the vast majority of
\&\f(CW\*(C`DBD::SQLite\*(C'\fR users. If, however, there are any applications
that nevertheless were built using the \*(L"Standard Query\*(R" syntax,
they have to be migrated, because the precedence of the \f(CW\*(C`OR\*(C'\fR operator
has changed. Conversion from old to new syntax can be
automated through DBD::SQLite::FTS3Transitional, published
in a separate distribution.
.SS "Tokenizers"
.IX Subsection "Tokenizers"
The behaviour of full-text indexes strongly depends on how
documents are split into \fItokens\fR; therefore \s-1FTS3\s0 table
declarations can explicitly specify how to perform
tokenization:
.PP
.Vb 1
\& CREATE ... USING fts3(, tokenize=)
.Ve
.PP
where \f(CW\*(C`\*(C'\fR is a sequence of space-separated
words that triggers a specific tokenizer, as explained below.
.PP
\fISQLite builtin tokenizers\fR
.IX Subsection "SQLite builtin tokenizers"
.PP
SQLite comes with three builtin tokenizers :
.IP "simple" 4
.IX Item "simple"
Under the \fIsimple\fR tokenizer, a term is a contiguous sequence of
eligible characters, where eligible characters are all alphanumeric
characters, the \*(L"_\*(R" character, and all characters with \s-1UTF\s0 codepoints
greater than or equal to 128. All other characters are discarded when
splitting a document into terms. They serve only to separate adjacent
terms.
.Sp
All uppercase characters within the \s-1ASCII\s0 range (\s-1UTF\s0 codepoints less
than 128), are transformed to their lowercase equivalents as part of
the tokenization process. Thus, full-text queries are case-insensitive
when using the simple tokenizer.
.IP "porter" 4
.IX Item "porter"
The \fIporter\fR tokenizer uses the same rules to separate the input
document into terms, but as well as folding all terms to lower case it
uses the Porter Stemming algorithm to reduce related English language
words to a common root.
.IP "icu" 4
.IX Item "icu"
If SQLite is compiled with the \s-1SQLITE_ENABLE_ICU\s0
pre-processor symbol defined, then there exists a built-in tokenizer
named \*(L"icu\*(R" implemented using the \s-1ICU\s0 library, and taking an
\&\s-1ICU\s0 locale identifier as argument (such as \*(L"tr_TR\*(R" for
Turkish as used in Turkey, or \*(L"en_AU\*(R" for English as used in
Australia). For example:
.Sp
.Vb 1
\& CREATE VIRTUAL TABLE thai_text USING fts3(text, tokenize=icu th_TH)
.Ve
.Sp
The \s-1ICU\s0 tokenizer implementation is very simple. It splits the input
text according to the \s-1ICU\s0 rules for finding word boundaries and
discards any tokens that consist entirely of white-space. This may be
suitable for some applications in some locales, but not all. If more
complex processing is required, for example to implement stemming or
discard punctuation, use the perl tokenizer as explained below.
.PP
\fIPerl tokenizers\fR
.IX Subsection "Perl tokenizers"
.PP
In addition to the builtin SQLite tokenizers, \f(CW\*(C`DBD::SQLite\*(C'\fR
implements a \fIperl\fR tokenizer, that can hook to any tokenizing
algorithm written in Perl. This is specified as follows :
.PP
.Vb 1
\& CREATE ... USING fts3(, tokenize=perl \*(Aq\*(Aq)
.Ve
.PP
where \f(CW\*(C`\*(C'\fR is a fully qualified Perl function name
(i.e. prefixed by the name of the package in which that function is
declared). So for example if the function is \f(CW\*(C`my_func\*(C'\fR in the main
program, write
.PP
.Vb 1
\& CREATE ... USING fts3(, tokenize=perl \*(Aqmain::my_func\*(Aq)
.Ve
.PP
That function should return a code reference that takes a string as
single argument, and returns an iterator (another function), which
returns a tuple \f(CW\*(C`($term, $len, $start, $end, $index)\*(C'\fR for each
term. Here is a simple example that tokenizes on words according to
the current perl locale
.PP
.Vb 3
\& sub locale_tokenizer {
\& return sub {
\& my $string = shift;
\&
\& use locale;
\& my $regex = qr/\ew+/;
\& my $term_index = 0;
\&
\& return sub { # closure
\& $string =~ /$regex/g or return; # either match, or no more token
\& my ($start, $end) = ($\-[0], $+[0]);
\& my $len = $end\-$start;
\& my $term = substr($string, $start, $len);
\& return ($term, $len, $start, $end, $term_index++);
\& }
\& };
\& }
.Ve
.PP
There must be three levels of subs, in a kind of \*(L"Russian dolls\*(R" structure,
because :
.IP "\(bu" 4
the external, named sub is called whenever accessing a \s-1FTS3\s0 table
with that tokenizer
.IP "\(bu" 4
the inner, anonymous sub is called whenever a new string
needs to be tokenized (either for inserting new text into the table,
or for analyzing a query).
.IP "\(bu" 4
the innermost, anonymous sub is called repeatedly for retrieving
all terms within that string.
.PP
Instead of writing tokenizers by hand, you can grab one of those
already implemented in the Search::Tokenizer module :
.PP
.Vb 4
\& use Search::Tokenizer;
\& $dbh\->do(<<"") or die DBI::errstr;
\& CREATE ... USING fts3(,
\& tokenize=perl \*(AqSearch::Tokenizer::unaccent\*(Aq)
.Ve
.PP
or you can use \*(L"new\*(R" in Search::Tokenizer to build
your own tokenizer.
.SS "Incomplete handling of utf8 characters"
.IX Subsection "Incomplete handling of utf8 characters"
The current \s-1FTS3\s0 implementation in SQLite is far from complete with
respect to utf8 handling : in particular, variable-length characters
are not treated correctly by the builtin functions
\&\f(CW\*(C`offsets()\*(C'\fR and \f(CW\*(C`snippet()\*(C'\fR.
.SS "Database space for \s-1FTS3\s0"
.IX Subsection "Database space for FTS3"
\&\s-1FTS3\s0 stores a complete copy of the indexed documents, together with
the fulltext index. On a large collection of documents, this can
consume quite a lot of disk space. If copies of documents are also
available as external resources (for example files on the filesystem),
that space can sometimes be spared \-\-\- see the tip in the
Cookbook.
.SH "R* TREE SUPPORT"
.IX Header "R* TREE SUPPORT"
The \s-1RTREE\s0 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 :
.PP
.Vb 5
\& CREATE VIRTUAL TABLE city_buildings USING rtree(
\& id, \-\- Integer primary key
\& minLong, maxLong, \-\- Minimum and maximum longitude
\& minLat, maxLat \-\- Minimum and maximum latitude
\& );
.Ve
.PP
then query which buildings overlap or are contained within a specified region:
.PP
.Vb 5
\& # IDs that are contained within query coordinates
\& my $contained_sql = <<"";
\& SELECT id FROM try_rtree
\& WHERE minLong >= ? AND maxLong <= ?
\& AND minLat >= ? AND maxLat <= ?
\&
\& # ... and those that overlap query coordinates
\& my $overlap_sql = <<"";
\& SELECT id FROM try_rtree
\& 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);
.Ve
.PP
For more detail, please see the SQLite R\-Tree page
(). Note that custom R\-Tree
queries using callbacks, as mentioned in the prior link, have not been
implemented yet.
.SH "FOR DBD::SQLITE EXTENSION AUTHORS"
.IX Header "FOR DBD::SQLITE EXTENSION AUTHORS"
Since 1.30_01, you can retrieve the bundled sqlite C source and/or
header like this:
.PP
.Vb 2
\& use File::ShareDir \*(Aqdist_dir\*(Aq;
\& use File::Spec::Functions \*(Aqcatfile\*(Aq;
\&
\& # the whole sqlite3.h header
\& my $sqlite3_h = catfile(dist_dir(\*(AqDBD\-SQLite\*(Aq), \*(Aqsqlite3.h\*(Aq);
\&
\& # or only a particular header, amalgamated in sqlite3.c
\& my $what_i_want = \*(Aqparse.h\*(Aq;
\& my $sqlite3_c = catfile(dist_dir(\*(AqDBD\-SQLite\*(Aq), \*(Aqsqlite3.c\*(Aq);
\& open my $fh, \*(Aq<\*(Aq, $sqlite3_c or die $!;
\& my $code = do { local $/; <$fh> };
\& my ($parse_h) = $code =~ m{(
\& /\e*+[ ]Begin[ ]file[ ]$what_i_want[ ]\e*+
\& .+?
\& /\e*+[ ]End[ ]of[ ]$what_i_want[ ]\e*+/
\& )}sx;
\& open my $out, \*(Aq>\*(Aq, $what_i_want or die $!;
\& print $out $parse_h;
\& close $out;
.Ve
.PP
You usually want to use this in your extension's \f(CW\*(C`Makefile.PL\*(C'\fR,
and you may want to add DBD::SQLite to your extension's \f(CW\*(C`CONFIGURE_REQUIRES\*(C'\fR
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).
.SH "TO DO"
.IX Header "TO DO"
The following items remain to be done.
.SS "Leak Detection"
.IX Subsection "Leak Detection"
Implement one or more leak detection tests that only run during
\&\s-1AUTOMATED_TESTING\s0 and \s-1RELEASE_TESTING\s0 and validate that none of the C
code we work with leaks.
.SS "Stream \s-1API\s0 for Blobs"
.IX Subsection "Stream API for Blobs"
Reading/writing into blobs using \f(CW\*(C`sqlite2_blob_open\*(C'\fR / \f(CW\*(C`sqlite2_blob_close\*(C'\fR.
.SS "Flags for sqlite3_open_v2"
.IX Subsection "Flags for sqlite3_open_v2"
Support the full \s-1API\s0 of sqlite3_open_v2 (flags for opening the file).
.SS "Support for custom callbacks for R\-Tree queries"
.IX Subsection "Support for custom callbacks for R-Tree queries"
Custom queries of a R\-Tree index using a callback are possible with
the SQLite C \s-1API\s0 (), so one could
potentially use a callback that narrowed the result set down based
on a specific need, such as querying for overlapping circles.
.SH "SUPPORT"
.IX Header "SUPPORT"
Bugs should be reported via the \s-1CPAN\s0 bug tracker at
.PP
http://rt.cpan.org/NoAuth/ReportBug.html?Queue=DBD\-SQLite
.PP
Note that bugs of bundled sqlite library (i.e. bugs in \f(CW\*(C`sqlite3.[ch]\*(C'\fR)
should be reported to the sqlite developers at sqlite.org via their bug
tracker or via their mailing list.
.SH "AUTHORS"
.IX Header "AUTHORS"
Matt Sergeant
.PP
Francis J. Lacoste
.PP
Wolfgang Sourdeau
.PP
Adam Kennedy
.PP
Max Maischein
.PP
Laurent Dami
.PP
Kenichi Ishigaki
.SH "COPYRIGHT"
.IX Header "COPYRIGHT"
The bundled SQLite code in this distribution is Public Domain.
.PP
DBD::SQLite is copyright 2002 \- 2007 Matt Sergeant.
.PP
Some parts copyright 2008 Francis J. Lacoste.
.PP
Some parts copyright 2008 Wolfgang Sourdeau.
.PP
Some parts copyright 2008 \- 2012 Adam Kennedy.
.PP
Some parts copyright 2009 \- 2012 Kenichi Ishigaki.
.PP
Some parts derived from DBD::SQLite::Amalgamation
copyright 2008 Audrey Tang.
.PP
This program is free software; you can redistribute
it and/or modify it under the same terms as Perl itself.
.PP
The full text of the license can be found in the
\&\s-1LICENSE\s0 file included with this module.