NAME
    DBD::SQLite - Self-contained RDBMS in a DBI Driver

SYNOPSIS
      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 <http://www.sqlite.org/>.

    DBD::SQLite is a Perl DBI driver for SQLite, that includes the entire
    thing in the distribution. So in order to get a fast transaction capable
    RDBMS working for your perl project you simply have to install this
    module, and nothing else.

    SQLite supports the following features:

    Implements a large subset of SQL92
        See <http://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.

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.

    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.

  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 two 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);

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

    <http://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);

  Foreign Keys
    BE PREPARED! WOLVES APPROACH!!

    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.

    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:

      $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. It is very
    likely that the sqlite team will turn it default-on in the future, and
    we plan to do it NO LATER THAN they do so.

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

  Pragma
    SQLite has a set of "Pragma"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 DBD libraries, but you may find some of these are quite
    useful. DBD::SQLite actually sets some (like "show_datatypes") for you
    when you connect to a database. See <http://www.sqlite.org/pragma.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
        begins 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
    Transaction by "AutoCommit" or "begin_work" is nice and handy, but
    sometimes you may get an annoying "database is locked" 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 "commit" statement, it allows
    other people to read from the database. However, reading from the
    database also requires "shared lock", and that prevents to give you the
    "exclusive lock" you reserved, thus you get the "database is locked"
    error, and other people will get the same error if they try to write
    afterwards, as you still have a "pending" lock. "busy_timeout" doesn't
    help in this case.

    To avoid this, set a transaction type explicitly. You can issue a "begin
    immediate transaction" (or "begin exclusive transaction") for each
    transaction, or set "sqlite_use_immediate_transaction" database handle
    attribute to true (since 1.30_02) to always use an immediate transaction
    (even when you simply use "begin_work" or turn off the "AutoCommit".).

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

    Note that this works only when all of the connections use the same
    (non-deferred) transaction. See <http://sqlite.org/lockingv3.html> for
    locking details.

  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.

    Since 1.30_01, you can retrieve those ignored (unprepared) statements
    via "$sth->{sqlite_unprepared_statements}". 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
    "sqlite_allow_multiple_statements" attribute of a database handle to
    true when you connect to a database, "do" method automatically checks
    the "sqlite_unprepared_statements" 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.

  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
  Database Handle Attributes
    sqlite_version
        Returns the version of the SQLite library which DBD::SQLite is
        using, e.g., "2.8.0". Can only be read.

    sqlite_unicode
        If set to a true value, DBD::SQLite will turn the UTF-8 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 UTF-8
        flag see perlunicode. The default is for the UTF-8 flag to be turned
        off.

        Also note that due to some bizarreness in SQLite's type system (see
        <http://www.sqlite.org/datatype3.html>), if you want to retain
        blob-style behavior for some columns under "$dbh->{sqlite_unicode} =
        1" (say, to store images in the database), you have to state so
        explicitly using the 3-argument form of "bind_param" in DBI when
        doing updates:

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

        Defining the column type as "BLOB" in the DDL is not sufficient.

        This attribute was originally named as "unicode", and renamed to
        "sqlite_unicode" for integrity since version 1.26_06. Old "unicode"
        attribute is still accessible but will be deprecated in the near
        future.

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

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

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

METHODS
    See also to the DBI documentation for the details of other common
    methods.

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

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

    The following fields are returned:

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

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

    TABLE_NAME: The name of the table or view.

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

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

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

DRIVER PRIVATE METHODS
    The following methods can be called via the func() method with a little
    tweak, but the use of func() method is now discouraged by the DBI author
    for various reasons (see DBI's document
    <http://search.cpan.org/dist/DBI/lib/DBI/DBD.pm#Using_install_method()_t
    o_expose_driver-private_methods> for details). So, if you're using DBI
    >= 1.608, use these "sqlite_" methods. If you need to use an older DBI,
    you can call these like this:

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

  $dbh->sqlite_last_insert_rowid()
    This method returns the last inserted rowid. If you specify an INTEGER
    PRIMARY KEY as the first column in your table, that is the column that
    is returned. Otherwise, it is the hidden ROWID column. See the sqlite
    docs for details.

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

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

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

  $dbh->sqlite_busy_timeout()
    Retrieve the current busy timeout.

  $dbh->sqlite_busy_timeout( $ms )
    Set the current busy timeout. The timeout is in milliseconds.

  $dbh->sqlite_create_function( $name, $argc, $code_ref )
    This method will register a new function which will be usable in an SQL
    query. 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 taken by the function. If this number is -1,
        the function can take any number of arguments.

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

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

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

    After this, it could be use from SQL as:

      INSERT INTO mytable ( now() );

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

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

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

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

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

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

  $dbh->sqlite_create_collation( $name, $code_ref )
    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 should register the desired collation using
    "sqlite_create_collation".

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

  $dbh->sqlite_create_aggregate( $name, $argc, $pkg )
    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.

    The aggregator interface consists of defining three methods:

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

    step(@_)
        This method will be called once for each row in the aggregate.

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

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

      package variance;
      
  sub new { bless [], shift; }
      
  sub step {
          my ( $self, $value ) = @_;
      
      push @$self, $value;
      }
      
  sub finalize {
          my $self = $_[0];
      
      my $n = @$self;
      
      # Variance is NULL unless there is more than one row
          return undef unless $n || $n == 1;
      
      my $mu = 0;
          foreach my $v ( @$self ) {
              $mu += $v;
          }
          $mu /= $n;
      
      my $sigma = 0;
          foreach my $v ( @$self ) {
              $sigma += ($x - $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).

  $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 then "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.

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

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

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

  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.

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 "DBD::Sqlite" module must be explicitly "use"d 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
    <http://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
    SQLite v3 provides the ability for users to supply arbitrary comparison
    functions, known as user-defined "collation sequences" or "collating
    functions", to be used for comparing two text values.
    <http://www.sqlite.org/datatype3.html#collation> explains how collations
    are used in various SQL expressions.

  Builtin collation sequences
    The following collation sequences are builtin within SQLite :

    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
    If the attribute "$dbh->{sqlite_unicode}" 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 "sqlite_unicode"
    attribute is set before the first call to a perl collation sequence .
    The recommended way to activate unicode is to set the parameter at
    connection time :

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

  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
    The FTS3 extension module within SQLite allows users to create special
    tables with a built-in full-text index (hereafter "FTS3 tables"). 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 "token"), even if the table contains many large documents.

  Short introduction to FTS3
    The detailed documentation for FTS3 can be found at
    <http://www.sqlite.org/fts3.html>. Here is a very short example :

      $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 'foo'

    The key points in this example are :

    *   The syntax for creating FTS3 tables is

          CREATE VIRTUAL TABLE <table_name> USING fts3(<columns>)

        where "<columns>" 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 "content". In addition, FTS3
        tables have an implicit column called "docid" (or also "rowid") for
        numbering the stored documents.

    *   Statements for inserting, updating or deleting records use the same
        syntax as for regular SQLite tables.

    *   Full-text searches are specified with the "MATCH" operator, and an
        operand which may be a single word, a word prefix ending with '*', a
        list of words, a "phrase query" in double quotes, or a boolean
        combination of the above.

    *   The builtin function "snippet(...)" builds a formatted excerpt of
        the document text, where the words pertaining to the query are
        highlighted.

    There are many more details to building and searching FTS3 tables, so we
    strongly invite you to read the full documentation at at
    <http://www.sqlite.org/fts3.html>.

    Incompatible change : starting from version 1.31, "DBD::SQLite" uses the
    new, recommended "Enhanced Query Syntax" for binary set operators (AND,
    OR, NOT, possibly nested with parenthesis). Previous versions of
    "DBD::SQLite" used the "Standard Query Syntax" (see
    <http://www.sqlite.org/fts3.html#section_3_2>). Unfortunately this is a
    compilation switch, so it cannot be tuned at runtime; however, since
    FTS3 was never advertised in versions prior to 1.31, the change should
    be invisible to the vast majority of "DBD::SQLite" users. If, however,
    there are any applications that nevertheless were built using the
    "Standard Query" syntax, they have to be migrated, because the
    precedence of the "OR" operator has changed. Conversion from old to new
    syntax can be automated through DBD::SQLite::FTS3Transitional, published
    in a separate distribution.

  Tokenizers
    The behaviour of full-text indexes strongly depends on how documents are
    split into *tokens*; therefore FTS3 table declarations can explicitly
    specify how to perform tokenization:

      CREATE ... USING fts3(<columns>, tokenize=<tokenizer>)

    where "<tokenizer>" is a sequence of space-separated words that triggers
    a specific tokenizer, as explained below.

   SQLite builtin tokenizers
    SQLite comes with three builtin tokenizers :

    simple
        Under the *simple* tokenizer, a term is a contiguous sequence of
        eligible characters, where eligible characters are all alphanumeric
        characters, the "_" character, and all characters with UTF
        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.

        All uppercase characters within the ASCII range (UTF 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.

    porter
        The *porter* 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.

    icu If SQLite is compiled with the SQLITE_ENABLE_ICU pre-processor
        symbol defined, then there exists a built-in tokenizer named "icu"
        implemented using the ICU library, and taking an ICU locale
        identifier as argument (such as "tr_TR" for Turkish as used in
        Turkey, or "en_AU" for English as used in Australia). For example:

          CREATE VIRTUAL TABLE thai_text USING fts3(text, tokenize=icu th_TH)

        The ICU tokenizer implementation is very simple. It splits the input
        text according to the ICU 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.

   Perl tokenizers
    In addition to the builtin SQLite tokenizers, "DBD::Sqlite" implements a
    *perl* tokenizer, that can hook to any tokenizing algorithm written in
    Perl. This is specified as follows :

      CREATE ... USING fts3(<columns>, tokenize=perl '<perl_function>')

    where "<perl_function>" 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 "my_func" in the main program, write

      CREATE ... USING fts3(<columns>, tokenize=perl 'main::my_func')

    That function should return a code reference that takes a string as
    single argument, and returns an iterator (another function), which
    returns a tuple "($term, $len, $start, $end, $index)" for each term.
    Here is a simple example that tokenizes on words according to the
    current perl locale

      sub locale_tokenizer {
        return sub {
          my $string = shift;

          use locale;
          my $regex      = qr/\w+/;
          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++);
          }
        };
      }

    There must be three levels of subs, in a kind of "Russian dolls"
    structure, because :

    *   the external, named sub is called whenever accessing a FTS3 table
        with that tokenizer

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

    *   the innermost, anonymous sub is called repeatedly for retrieving all
        terms within that string.

    Instead of writing tokenizers by hand, you can grab one of those already
    implemented in the Search::Tokenizer module :

      use Search::Tokenizer;
      $dbh->do(<<"") or die DBI::errstr;
      CREATE ... USING fts3(<columns>, 
                            tokenize=perl 'Search::Tokenizer::unaccent')

    or you can use "new" in Search::Tokenizer to build your own tokenizer.

  Incomplete handling of utf8 characters
    The current FTS3 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 "offsets()" and
    "snippet()".

  Database space for FTS3
    FTS3 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.

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.

  Warnings Upgrade
    We currently use a horridly hacky method to issue and suppress warnings.
    It suffices for now, but just barely.

    Migrate all of the warning code to use the recommended DBI warnings.

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

  Flags for sqlite3_open_v2
    Support the full API of sqlite3_open_v2 (flags for opening the file).

SUPPORT
    Bugs should be reported via the CPAN bug tracker at

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

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 - 2010 Adam Kennedy.

    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.

