/ 
Mojo-mysql-1.03
River stage one • 3 direct dependents • 5 total dependents
/ Mojo::mysql::Database

NAME

Mojo::mysql::Database - Database

SYNOPSIS

use Mojo::mysql::Database;

my $db = Mojo::mysql::Database->new(mysql => $mysql, dbh => $dbh);

DESCRIPTION

Mojo::mysql::Database is a container for database handles used by Mojo::MySQL.

ATTRIBUTES

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

dbh

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

Database handle used for all queries.

mysql

my $mysql = $db->mysql;
$db       = $db->mysql(Mojo::mysql->new);

Mojo::mysql object this database belongs to.

results_class

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

METHODS

Mojo::mysql::Database inherits all methods from Mojo::EventEmitter and implements the following new ones.

backlog

my $num = $db->backlog;

Number of waiting non-blocking queries.

begin

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 $@;

delete

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.

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

disconnect

$db->disconnect;

Disconnect database handle and prevent it from getting cached again.

insert

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.

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

pid

my $pid = $db->pid;

Return the connection id of the backend server process.

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

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

# Insert binary data
use DBI ':sql_types';
$db->query('insert into bar values (?)', {type => SQL_BLOB, value => $bytes});

quote

 my $escaped = $db->quote($str);

Quote a string literal for use as a literal value in an SQL statement.

quote_id

 my $escaped = $db->quote_id($id);

Quote an identifier (table name etc.) for use in an SQL statement.

select

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.

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

update

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.

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

SEE ALSO

Mojo::mysql.