Mojo::mysql::Database - Database
use Mojo::mysql::Database; my $db = Mojo::mysql::Database->new(mysql => $mysql, dbh => $dbh);
Mojo::mysql::Database is a container for database handles used by Mojo::MySQL.
Mojo::mysql::Database implements the following attributes.
my $dbh = $db->dbh; $db = $db->dbh(DBI->new);
Database handle used for all queries.
my $mysql = $db->mysql; $db = $db->mysql(Mojo::mysql->new);
Mojo::mysql object this database belongs to.
$class = $db->results_class; $db = $db->results_class("MyApp::Results");
Class to be used by "query", defaults to Mojo::mysql::Results. Note that this class needs to have already been loaded before "query" is called.
Mojo::mysql::Database inherits all methods from Mojo::EventEmitter and implements the following new ones.
my $num = $db->backlog;
Number of waiting non-blocking queries.
my $tx = $db->begin;
Begin transaction and return Mojo::mysql::Transaction object, which will automatically roll back the transaction unless "commit" in Mojo::mysql::Transaction bas been called before it is destroyed.
# Add names in a transaction eval { my $tx = $db->begin; $db->query('insert into names values (?)', 'Baerbel'); $db->query('insert into names values (?)', 'Wolfgang'); $tx->commit; }; say $@ if $@;
my $results = $db->delete($table, \%where);
Generate a DELETE statement with "abstract" in Mojo::mysql (usually an SQL::Abstract object) and execute it with "query". You can also append a callback to perform operations non-blocking.
DELETE
$db->delete(some_table => sub { my ($db, $err, $results) = @_; ... }); Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
my $promise = $db->delete_p($table, \%where, \%options); Same as L</"delete">, but performs all operations non-blocking and returns a L<Mojo::Promise> object instead of accepting a callback. $db->delete_p('some_table')->then(sub { my $results = shift; ... })->catch(sub { my $err = shift; ... })->wait;
$db->disconnect;
Disconnect database handle and prevent it from getting cached again.
my $results = $db->insert($table, \@values || \%fieldvals, \%options);
Generate an INSERT statement with "abstract" in Mojo::mysql (usually an SQL::Abstract object) and execute it with "query". You can also append a callback to perform operations non-blocking.
INSERT
$db->insert(some_table => {foo => 'bar'} => sub { my ($db, $err, $results) = @_; ... }); Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
my $promise = $db->insert_p($table, \@values || \%fieldvals, \%options);
Same as "insert", but performs all operations non-blocking and returns a Mojo::Promise object instead of accepting a callback.
$db->insert_p(some_table => {foo => 'bar'})->then(sub { my $results = shift; ... })->catch(sub { my $err = shift; ... })->wait;
my $pid = $db->pid;
Return the connection id of the backend server process.
my $bool = $db->ping;
Check database connection.
my $results = $db->query('select * from foo'); my $results = $db->query('insert into foo values (?, ?, ?)', @values); my $results = $db->query('insert into foo values (?)', {json => {bar => 'baz'}}); my $results = $db->query('insert into foo values (?)', {type => SQL_INTEGER, value => 42});
Execute a blocking statement and return a Mojo::mysql::Results object with the results. You can also append a callback to perform operation non-blocking.
$db->query('select * from foo' => sub { my ($db, $err, $results) = @_; ... }); Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
Hash reference arguments containing a value named json, will be encoded to JSON text with "to_json" in Mojo::JSON. To accomplish the reverse, you can use the method "expand" in Mojo::mysql::Results, which automatically decodes data back to Perl data structures.
json
$db->query('insert into foo values (x) values (?)', {json => {bar => 'baz'}}); $db->query('select * from foo')->expand->hash->{x}{bar}; # baz
Hash reference arguments containing values named type and value can be used to bind specific DBI data types (see "DBI Constants" in DBI) to placeholders. This is needed to pass binary data in parameters; see "mysql_enable_utf8" in DBD::mysql for more information.
type
value
# Insert binary data use DBI ':sql_types'; $db->query('insert into bar values (?)', {type => SQL_BLOB, value => $bytes});
my $promise = $db->query_p('select * from foo');
Same as "query", but performs all operations non-blocking and returns a Mojo::Promise object instead of accepting a callback.
$db->query_p('insert into foo values (?, ?, ?)' => @values)->then(sub { my $results = shift; ... })->catch(sub { my $err = shift; ... })->wait;
my $escaped = $db->quote($str);
Quote a string literal for use as a literal value in an SQL statement.
my $escaped = $db->quote_id($id);
Quote an identifier (table name etc.) for use in an SQL statement.
my $results = $db->select($source, $fields, $where, $order);
Generate a SELECT statement with "abstract" in Mojo::mysql (usually an SQL::Abstract object) and execute it with "query". You can also append a callback to perform operations non-blocking.
SELECT
$db->select(some_table => ['foo'] => sub { my ($db, $err, $results) = @_; ... }); Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
my $promise = $db->select_p($source, $fields, $where, $order);
Same as "select", but performs all operations non-blocking and returns a Mojo::Promise object instead of accepting a callback.
$db->select_p(some_table => ['foo'] => {bar => 'yada'})->then(sub { my $results = shift; ... })->catch(sub { my $err = shift; ... })->wait;
my $results = $db->update($table, \%fieldvals, \%where);
Generate an UPDATE statement with "abstract" in Mojo::mysql (usually an SQL::Abstract object) and execute it with "query". You can also append a callback to perform operations non-blocking.
UPDATE
$db->update(some_table => {foo => 'baz'} => {foo => 'bar'} => sub { my ($db, $err, $results) = @_; ... }); Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
my $promise = $db->update_p($table, \%fieldvals, \%where, \%options);
Same as "update", but performs all operations non-blocking and returns a Mojo::Promise object instead of accepting a callback.
$db->update_p(some_table => {foo => 'baz'} => {foo => 'bar'})->then(sub { my $results = shift; ... })->catch(sub { my $err = shift; ... })->wait;
my $tables = $db->tables;
Return an array reference with table names for this database.
Mojo::mysql.
To install Mojo::mysql, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Mojo::mysql
CPAN shell
perl -MCPAN -e shell install Mojo::mysql
For more information on module installation, please visit the detailed CPAN module installation guide.