NAME

       Mojo::SQLite::Database - Database

SYNOPSIS

         use Mojo::SQLite::Database;

         my $db = Mojo::SQLite::Database->new(sqlite => $sql, dbh => $dbh);
         $db->query('select * from foo')
           ->hashes->map(sub { $_->{bar} })->join("\n")->say;

DESCRIPTION

       Mojo::SQLite::Database is a container for DBD::SQLite database handles used by
       Mojo::SQLite.

ATTRIBUTES

       Mojo::SQLite::Database implements the following attributes.

   dbh
         my $dbh = $db->dbh;
         $db     = $db->dbh($dbh);

       DBD::SQLite database handle used for all queries.

         # Use DBI utility methods
         my $quoted = $db->dbh->quote_identifier('foo.bar');

   results_class
         my $class = $db->results_class;
         $db       = $db->results_class('MyApp::Results');

       Class to be used by "query", defaults to Mojo::SQLite::Results. Note that this class needs
       to have already been loaded before "query" is called.

   sqlite
         my $sql = $db->sqlite;
         $db     = $db->sqlite(Mojo::SQLite->new);

       Mojo::SQLite object this database belongs to.

METHODS

       Mojo::SQLite::Database inherits all methods from Mojo::Base and implements the following
       new ones.

   begin
         my $tx = $db->begin;
         my $tx = $db->begin('exclusive');

       Begin transaction and return Mojo::SQLite::Transaction object, which will automatically
       roll back the transaction unless "commit" in Mojo::SQLite::Transaction has been called
       before it is destroyed.

         # Insert rows in a transaction
         eval {
           my $tx = $db->begin;
           $db->insert('frameworks', {name => 'Catalyst'});
           $db->insert('frameworks', {name => 'Mojolicious'});
           $tx->commit;
         };
         say $@ if $@;

       A transaction locking behavior of "deferred", "immediate", or "exclusive" may optionally
       be passed; the default in DBD::SQLite is currently "immediate". See "Transaction and
       Database Locking" in DBD::SQLite and <https://sqlite.org/lang_transaction.html> for more
       details.

   delete
         my $results = $db->delete($table, \%where);

       Generate a "DELETE" statement with "abstract" in Mojo::SQLite (usually an
       SQL::Abstract::Pg object) and execute it with "query". You can also append a callback for
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->delete(some_table => sub ($db, $err, $results) {
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       Use all the same argument variations you would pass to the "delete" method of
       SQL::Abstract.

         # "delete from some_table"
         $db->delete('some_table');

         # "delete from some_table where foo = 'bar'"
         $db->delete('some_table', {foo => 'bar'});

         # "delete from some_table where foo like '%test%'"
         $db->delete('some_table', {foo => {-like => '%test%'}});

   delete_p
         my $promise = $db->delete_p($table, \%where, \%options);

       Same as "delete" but returns a Mojo::Promise object instead of accepting a callback. For
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->delete_p('some_table')->then(sub ($results) {
           ...
         })->catch(sub ($err) {
           ...
         })->wait;

   disconnect
         $db->disconnect;

       Disconnect "dbh" and prevent it from getting reused.

   insert
         my $results = $db->insert($table, \@values || \%fieldvals, \%options);

       Generate an "INSERT" statement with "abstract" in Mojo::SQLite (usually an
       SQL::Abstract::Pg object) and execute it with "query". You can also append a callback for
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->insert(some_table => {foo => 'bar'} => sub ($db, $err, $results) {
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       Use all the same argument variations you would pass to the "insert" method of
       SQL::Abstract.

         # "insert into some_table (foo, baz) values ('bar', 'yada')"
         $db->insert('some_table', {foo => 'bar', baz => 'yada'});

   insert_p
         my $promise = $db->insert_p($table, \@values || \%fieldvals, \%options);

       Same as "insert" but returns a Mojo::Promise object instead of accepting a callback. For
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->insert_p(some_table => {foo => 'bar'})->then(sub ($results) {
           ...
         })->catch(sub ($err) {
           ...
         })->wait;

   ping
         my $bool = $db->ping;

       Check database connection.

   query
         my $results = $db->query('select * from foo');
         my $results = $db->query('insert into foo values (?, ?, ?)', @values);
         my $results = $db->query('select ? as img', {type => SQL_BLOB, value => slurp 'img.jpg'});
         my $results = $db->query('select ? as foo', {json => {bar => 'baz'}});

       Execute a blocking SQL <http://www.postgresql.org/docs/current/static/sql.html> statement
       and return a results object based on "results_class" (which is usually
       Mojo::SQLite::Results) with the query results. The DBD::SQLite statement handle will be
       automatically reused when it is not active anymore, to increase the performance of future
       queries. You can also append a callback for API compatibility with Mojo::Pg; the query is
       still executed in a blocking manner.

         $db->query('insert into foo values (?, ?, ?)' => @values => sub ($db, $err, $results) {
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       Hash reference arguments containing "type" and "value" elements will use the specified
       bind type for the parameter, using types from "DBI Constants" in DBI; see "Blobs" in
       DBD::SQLite and the subsequent section for more information.

       Hash reference arguments containing a value named "json" or "-json" will be encoded to
       JSON text <http://sqlite.org/json1.html> with "to_json" in Mojo::JSON. To accomplish the
       reverse, you can use the method "expand" in Mojo::SQLite::Results to decode JSON text
       fields to Perl values with "from_json" in Mojo::JSON.

         # "I X SQLite!"
         $db->query('select ? as foo', {json => {bar => 'I X SQLite!'}})
           ->expand(json => 'foo')->hash->{foo}{bar};

   query_p
         my $promise = $db->query_p('SELECT * FROM foo');

       Same as "query" but returns a Mojo::Promise object instead of accepting a callback. For
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->query_p('INSERT INTO foo VALUES (?, ?, ?)' => @values)->then(sub ($results) {
           ...
         })->catch(sub ($err) {
           ...
         })->wait;

   select
         my $results = $db->select($source, $fields, $where, $order);

       Generate a "SELECT" statement with "abstract" in Mojo::SQLite (usually an
       SQL::Abstract::Pg object) and execute it with "query". You can also append a callback for
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->select(some_table => ['foo'] => {bar => 'yada'} => sub ($db, $err, $results) {
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       Use all the same argument variations you would pass to the "select" method of
       SQL::Abstract.

         # "select * from some_table"
         $db->select('some_table');

         # "select id, foo from some_table"
         $db->select('some_table', ['id', 'foo']);

         # "select * from some_table where foo = 'bar'"
         $db->select('some_table', undef, {foo => 'bar'});

         # "select * from some_table where foo = 'bar' order by id desc"
         $db->select('some_table', undef, {foo => 'bar'}, {-desc => 'id'});

         # "select * from some_table where foo like '%test%'"
         $db->select('some_table', undef, {foo => {-like => '%test%'}});

   select_p
         my $promise = $db->select_p($source, $fields, $where, \%options);

       Same as "select" but returns a Mojo::Promise object instead of accepting a callback. For
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->select_p(some_table => ['foo'] => {bar => 'yada'})->then(sub ($results) {
           ...
         })->catch(sub ($err) {
           ...
         })->wait;

   tables
         my $tables = $db->tables;

       Return table and view names for this database, that are visible to the current user and
       not internal, as an array reference. Names will be quoted and prefixed by a schema name of
       "main" for standard tables, "temp" for temporary tables, and the appropriate schema name
       for attached databases <http://sqlite.org/lang_attach.html>.

         # Names of all tables
         say for @{$db->tables};

   update
         my $results = $db->update($table, \%fieldvals, \%where);

       Generate an "UPDATE" statement with "abstract" in Mojo::SQLite (usually an
       SQL::Abstract::Pg object) and execute it with "query". You can also append a callback for
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->update(some_table => {foo => 'baz'} => {foo => 'bar'} => sub ($db, $err, $results) {
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       Use all the same argument variations you would pass to the "update" method of
       SQL::Abstract.

         # "update some_table set foo = 'bar' where id = 23"
         $db->update('some_table', {foo => 'bar'}, {id => 23});

         # "update some_table set foo = 'bar' where foo like '%test%'"
         $db->update('some_table', {foo => 'bar'}, {foo => {-like => '%test%'}});

   update_p
         my $promise = $db->update_p($table, \%fieldvals, \%where, \%options);

       Same as "update" but returns a Mojo::Promise object instead of accepting a callback. For
       API compatibility with Mojo::Pg; the query is still executed in a blocking manner.

         $db->update_p(some_table => {foo => 'baz'} => {foo => 'bar'})->then(sub ($results) {
           ...
         })->catch(sub ($err) {
           ...
         })->wait;

BUGS

       Report any issues on the public bugtracker.

AUTHOR

       Dan Book, "dbook@cpan.org"

COPYRIGHT AND LICENSE

       Copyright 2015, Dan Book.

       This library is free software; you may redistribute it and/or modify it under the terms of
       the Artistic License version 2.0.

SEE ALSO

       Mojo::SQLite