NAME
DB::Object - SQL API
SYNOPSIS
use DB::Object;
my $dbh = DB::Object->connect({
driver => 'Pg',
conf_file => 'db-settings.json',
database => 'webstore',
host => 'localhost',
login => 'store-admin',
schema => 'auth',
debug => 3,
}) || bailout( "Unable to connect to sql server on host localhost: ", DB::Object->error );
# Legacy regular query
my $sth = $dbh->prepare( "SELECT login,name FROM login WHERE login='jack'" ) ||
die( $dbh->errstr() );
$sth->execute() || die( $sth->errstr() );
my $ref = $sth->fetchrow_hashref();
$sth->finish();
# Get a list of databases;
my @databases = $dbh->databases;
# Doesn't exist? Create it:
my $dbh2 = $dbh->create_db( 'webstore' );
# Load some sql into it
my $rv = $dbh2->do( $sql ) || die( $dbh->error );
# Check a table exists
$dbh->table_exists( 'customers' ) || die( "Cannot find the customers table!\n" );
# Get list of tables, as array reference:
my $tables = $dbh->tables;
my $cust = $dbh->customers || die( "Cannot get customers object." );
$cust->where( email => 'john@example.org' );
my $str = $cust->delete->as_string;
# Becomes: DELETE FROM customers WHERE email='john\@example.org'
# Do some insert with transaction
$dbh->begin_work;
# Making some other inserts and updates here...
my $cust_sth_ins = $cust->insert(
first_name => 'Paul',
last_name => 'Goldman',
email => 'paul@example.org',
active => 0,
) || do
{
# Rollback everything since the begin_work
$dbh->rollback;
die( "Error while create query to add data to table customers: " . $cust->error );
};
$result = $cust_sth_ins->as_string;
# INSERT INTO customers (first_name, last_name, email, active) VALUES('Paul', 'Goldman', 'paul\@example.org', '0')
$dbh->commit;
## Get the last used insert id
my $id = $dbh->last_insert_id();
$cust->where( email => 'john@example.org' );
$cust->order( 'last_name' );
$cust->having( email => qr/\@example/ );
$cust->limit( 10 );
my $cust_sth_sel = $cust->select || die( "An error occurred while creating a query to select data frm table customers: " . $cust->error );
# Becomes:
# SELECT id, first_name, last_name, email, created, modified, active, created::ABSTIME::INTEGER AS created_unixtime, modified::ABSTIME::INTEGER AS modified_unixtime, CONCAT(first_name, ' ', last_name) AS name FROM customers WHERE email='john\@example.org' HAVING email ~ '\@example' ORDER BY last_name LIMIT 10
$cust->reset;
$cust->where( email => 'john@example.org' );
my $cust_sth_upd = $cust->update( active => 0 )
# Would become:
# UPDATE ONLY customers SET active='0' WHERE email='john\@example.org'
## Lets' dump the result of our query
## First to STDERR
$login->where( "login='jack'" );
$login->select->dump();
## Now dump the result to a file
$login->select->dump( "my_file.txt" );
Doing some left join
my $geo_tbl = $dbh->geoip || return( $self->error( "Unable to get the database object \"geoip\"." ) );
my $name_tbl = $dbh->geoname || return( $self->error( "Unable to get the database object \"geoname\"." ) );
$geo_tbl->as( 'i' );
$name_tbl->as( 'l' );
$geo_tbl->where( "INET '?'" << $geo_tbl->fo->network );
$geo_tbl->alias( id => 'ip_id' );
$name_tbl->alias( country_iso_code => 'code' );
my $sth = $geo_tbl->select->join( $name_tbl, $geo_tbl->fo->geoname_id == $name_tbl->fo->geoname_id );
# SELECT
# -- tables fields
# FROM
# geoip AS i
# LEFT JOIN geoname AS l ON i.geoname_id = l.geoname_id
# WHERE
# INET '?' << i.network
VERSION
v0.9.13
DESCRIPTION
DB::Object is a SQL API much alike "DBI". So why use a private module
instead of using that great "DBI" package?
At first, I started to inherit from "DBI" to conform to "perlmod" perl
manual page and to general perl coding guidlines. It became very quickly
a real hassle. Barely impossible to inherit, difficulty to handle error,
too much dependent from an API that change its behaviour with new
versions. In short, I wanted a better, more accurate control over the
SQL connection.
So, DB::Object acts as a convenient, modifiable wrapper that provide the
programmer with an intuitive, user-friendly and hassle free interface.
CONSTRUCTOR
new
Create a new instance of DB::Object. Nothing much to say.
connect
Provided with a "database", "login", "password", "server":["port"],
"driver", "schema", and optional hash or hash reference of parameters
and this will issue a database connection and return the resulting
database handler.
Create a new instance of DB::Object, but also attempts a connection to
SQL server.
It can take either an array of value in the order database name, login,
password, host, driver and optionally schema, or it can take a has or
hash reference. The hash or hash reference attributes are as follow:
*database* or *DB_NAME*
The database name you wish to connect to
*login* or *DB_LOGIN*
The login used to access that database
*passwd* or *DB_PASSWD*
The password that goes along
*host* or *DB_HOST*
The server, that is hostname of the machine serving a SQL server.
*port* or *DB_PORT*
The port to connect to
*driver* or *DB_DRIVER*
The driver you want to use. It needs to be of the same type than the
server you want to connect to. If you are connecting to a MySQL
server, you would use "mysql", if you would connecto to an Oracle
server, you would use "oracle".
You need to make sure that those driver are properly installed in
the system before attempting to connect.
To install the required driver, you could start with the command
line:
perl -MCPAN -e shell
which will provide you a special shell to install modules in a
convenient way.
*schema* or *DB_SCHEMA*
The schema to use to access the tables. Currently only used by
PostgreSQL
*opt*
This takes a hash reference and contains the standard "DBI" options
such as *PrintError*, *RaiseError*, *AutoCommit*, etc
*conf_file* or *DB_CON_FILE*
This is used to specify a json connection configuration file. It can
also provided via the environment variable *DB_CON_FILE*. It has the
following structure:
{
"database": "some_database",
"host": "db.example.com",
"login": "sql_joe",
"passwd": "some password",
"driver": "Pg",
"schema": "warehouse",
"opt":
{
"RaiseError": false,
"PrintError": true,
"AutoCommit": true
}
}
Alternatively, it can contain connections parameters for multiple
databases and drivers, such as:
{
"databases": [
{
"database": "some_database",
"host": "db.example.com",
"port": 5432,
"login": "sql_joe",
"passwd": "some password",
"driver": "Pg",
"schema": "warehouse",
"opt":
{
"RaiseError": false,
"PrintError": true,
"AutoCommit": true
}
},
{
"database": "other_database",
"host": "db.example2.com",
"login": "sql_bob",
"passwd": "other password",
"driver": "mysql",
},
{
"database": "/path/to/my/database.sqlite",
"driver": "SQLite",
}
]
}
*uri* or *DB_CON_URI*
This is used to specify an uri to contain all the connection
parameters for one database connection. It can also provided via the
environment variable *DB_CON_URI*. For example:
http://db.example.com:5432?database=some_database&login=sql_joe&passwd=some%020password&driver=Pg&schema=warehouse&&opt=%7B%22RaiseError%22%3A+false%2C+%22PrintError%22%3Atrue%2C+%22AutoCommit%22%3Atrue%7D
Here the *opt* parameter is passed as a json string, for example:
{"RaiseError": false, "PrintError":true, "AutoCommit":true}
METHODS
alias
This is a convenient wrapper around "alias" in DB::Object::Query
It takes a column name to alias hash and sets those aliases for the
following query.
Get/set alias for table fields in SELECT queries. The hash provided thus
contain a list of field => alias pairs.
allow_bulk_delete
Sets/gets the boolean value for whether to allow unsafe bulk delete.
This means query without any "where" clause.
allow_bulk_update
Sets/gets the boolean value for whether to allow unsafe bulk update.
This means query without any "where" clause.
AND
Takes any arguments and wrap them into a "AND" clause.
$tbl->where( $dbh->AND( $tbl->fo->id == ?, $tbl->fo->frequency >= .30 ) );
auto_convert_datetime_to_object
Sets or gets the boolean value. If true, then this api will
automatically transcode datetime value into their equivalent DateTime
object.
auto_decode_json
Sets or gets the boolean value. If true, then this api will
automatically transcode json data into perl hash reference.
as_string
Return the sql query as a string.
avoid
Takes a list of array reference of column to avoid in the next query.
This is a convenient wrapper around "avoid" in DB::Object::Query
attribute
Sets or get the value of database connection parameters.
If only one argument is provided, returns its value. If multiple
arguments in a form of pair => value are provided, it sets the
corresponding database parameters.
The authorised parameters are:
*Active*
Is read-only.
*ActiveKids*
Is read-only.
*AutoCommit*
Can be changed.
*AutoInactiveDestroy*
Can be changed.
*CachedKids*
Is read-only.
*Callbacks*
Can be changed.
*ChildHandles*
Is read-only.
*ChopBlanks*
Can be changed.
*CompatMode*
Can be changed.
*CursorName*
Is read-only.
*ErrCount*
Is read-only.
*Executed*
Is read-only.
*FetchHashKeyName*
Is read-only.
*HandleError*
Can be changed.
*HandleSetErr*
Can be changed.
*InactiveDestroy*
Can be changed.
*Kids*
Is read-only.
*LongReadLen*
Can be changed.
*LongTruncOk*
Can be changed.
*NAME*
Is read-only.
*NULLABLE*
Is read-only.
*NUM_OF_FIELDS*
Is read-only.
*NUM_OF_PARAMS*
Is read-only.
*Name*
Is read-only.
*PRECISION*
Is read-only.
*PrintError*
Can be changed.
*PrintWarn*
Can be changed.
*Profile*
Is read-only.
*RaiseError*
Can be changed.
*ReadOnly*
Can be changed.
*RowCacheSize*
Is read-only.
*RowsInCache*
Is read-only.
*SCALE*
Is read-only.
*ShowErrorStatement*
Can be changed.
*Statement*
Is read-only.
*TYPE*
Is read-only.
*Taint*
Can be changed.
*TaintIn*
Can be changed.
*TaintOut*
Can be changed.
*TraceLevel*
Can be changed.
*Type*
Is read-only.
*Warn*
Can be changed.
available_drivers
Return the list of available drivers.
base_class
Returns the base class.
bind
If no values to bind to the underlying query is provided, "bind" simply
activate the bind value feature.
If values are provided, they are allocated to the statement object and
will be applied when the query will be executed.
Example:
$dbh->bind()
# or
$dbh->bind->where( "something" )
# or
$dbh->bind->select->fetchrow_hashref()
# and then later
$dbh->bind( 'thingy' )->select->fetchrow_hashref()
cache
Activate caching.
$tbl->cache->select->fetchrow_hashref();
cache_connections
Sets/get the cached database connection.
cache_dir
Sets or gets the directory on the file system used for caching data.
cache_tables
Sets or gets the DB::Object::Cache::Tables object.
check_driver
Check that the driver set in *$SQL_DRIVER* in ~/etc/common.cfg is indeed
available.
It does this by calling "available_drivers".
connect
This will attempt a database server connection.
It called "_connection_params2hash" to get the necessary connection
parameters, which is superseded in each driver package.
Then, it will call "_check_connect_param" to get the right parameters
for connection.
It will also call "_check_default_option" to get some driver specific
default options unless the previous call to _check_connect_param
returned an has with a property *opt*.
It will then set the following current object properties: "database",
"host", "port", "login", "passwd", "driver", "cache", "bind", "opt"
Unless specified in the connection options retrieved with
"_check_default_option", it sets some basic default value:
*AutoCommit* 1
*PrintError* 0
*RaiseError* 0
Finally it tries to connect by calling the, possibly superseded, method
"_dbi_connect"
It instantiate a DB::Object::Cache::Tables object to cache database
tables and return the current object.
constant_queries_cache
Returns the global value for $CONSTANT_QUERIES_CACHE
constant_queries_cache_get
Provided with some hash reference with properties "pack", "file" and
"line" that are together used as a key in the cache and this will use an
existing entry in the cache if available.
constant_queries_cache_set
Provided with some hash reference with properties "pack", "file" and
"line" that are together used as a key in the cache and "query_object"
and this will set an entry in the cache. it returns the hash reference
initially provided.
copy
Provided with either a reference to an hash or an hash of key => value
pairs, "copy" will first execute a select statement on the table object,
then fetch the row of data, then replace the key-value pair in the
result by the ones provided, and finally will perform an insert.
Return false if no data to copy were provided, otherwise it always
returns true.
create_db
This is a method that must be implemented by the driver package.
create_table
This is a method that must be implemented by the driver package.
data_sources
Given an optional list of options as hash, this return the data source
of the database handler.
data_type
Given a reference to an array or an array of data type, "data_type" will
check their availability in the database driver.
If nothing found, it return an empty list in list context, or undef in
scalar context.
If something was found, it returns a hash in list context or a reference
to a hash in list context.
database
Return the name of the current database.
databases
This returns the list of available databases.
This is a method that must be implemented by the driver package.
delete
"delete" will format a delete query based on previously set parameters,
such as "where".
"delete" will refuse to execute a query without a where condition. To
achieve this, one must prepare the delete query on his/her own by using
the "do" method and passing the sql query directly.
$tbl->where( login => 'jack' );
$tbl->limit(1);
my $rows_affected = $tbl->delete();
# or passing the where condition directly to delete
my $sth = $tbl->delete( login => 'jack' );
disconnect
Disconnect from database. Returns the return code.
my $rc = $dbh->disconnect;
do
Provided with a string representing a sql query, some hash reference of
attributes and some optional values to bind and this will execute the
query and return the statement handler.
The attributes list will be used to prepare the query and the bind
values will be used when executing the query.
Example:
$rc = $dbh->do( $statement ) || die( $dbh->errstr );
$rc = $dbh->do( $statement, \%attr ) || die( $dbh->errstr );
$rv = $dbh->do( $statement, \%attr, @bind_values ) || die( $dbh->errstr );
my $rows_deleted = $dbh->do(
q{
DELETE FROM table WHERE status = ?
}, undef(), 'DONE' ) || die( $dbh->errstr );
driver
Return the name of the driver for the current object.
enhance
Toggle the enhance mode on/off.
When on, the functions "from_unixtime" and "unix_timestamp" will be used
on date/time field to translate from and to unix time seamlessly.
err
Get the currently set error.
errno
Is just an alias for "err".
errmesg
Is just an alias for "errstr".
errstr
Get the currently set error string.
FALSE
This return the keyword "FALSE" to be used in queries.
fatal
Provided a boolean value and this toggles fatal mode on/off.
from_unixtime
Provided with an array or array reference of table columns and this will
set the list of fields that are to be treated as unix time and converted
accordingly after the sql query is executed.
It returns the list of fields in list context or a reference to an array
in scalar context.
format_statement
This is a convenient wrapper around "format_statement" in
DB::Object::Query
Format the sql statement for queries of types "select", "delete" and
"insert"
In list context, it returns 2 strings: one comma-separated list of
fields and one comma-separated list of values. In scalar context, it
only returns a comma-separated string of fields.
format_update
This is a convenient wrapper around "format_update" in DB::Object::Query
Formats update query based on the following arguments provided:
*data*
An array of key-value pairs to be used in the update query. This
array can be provided as the prime argument as a reference to an
array, an array, or as the *data* element of a hash or a reference
to a hash provided.
Why an array if eventually we build a list of key-value pair?
Because the order of the fields may be important, and if the
key-value pair list is provided, "format_update" honors the order in
which the fields are provided.
"format_update" will then iterate through each field-value pair, and
perform some work:
If the field being reviewed was provided to from_unixtime, then
"format_update" will enclose it in the function FROM_UNIXTIME() as in:
FROM_UNIXTIME(field_name)
If the the given value is a reference to a scalar, it will be used
as-is, ie. it will not be enclosed in quotes or anything. This is useful
if you want to control which function to use around that field.
If the given value is another field or looks like a function having
parenthesis, or if the value is a question mark, the value will be used
as-is.
If bind is off, the value will be escaped and the pair field='value'
created.
If the field is a SET data type and the value is a number, the value
will be used as-is without surrounding single quote.
If "bind" is enabled, a question mark will be used as the value and the
original value will be saved as value to bind upon executing the query.
Finally, otherwise the value is escaped and surrounded by single quotes.
"format_update" returns a string representing the comma-separated list
of fields that will be used.
group
This is a convenient wrapper around "group" in DB::Object::Query
host
Sets or gets the "host" property for this database object.
insert
This is a convenient wrapper around "insert" in DB::Object::Query
last_insert_id
Get the id of the primary key from the last insert.
limit
This is a convenient wrapper around "limit" in DB::Object::Query
local
This is a convenient wrapper around "local" in DB::Object::Query
lock
This method must be implemented by the driver package.
login
Sets or gets the "login" property for this database object.
no_bind
When invoked, "no_bind" will change any preparation made so far for
caching the query with bind parameters, and instead substitute the value
in lieu of the question mark placeholder.
no_cache
Disable caching of queries.
NOT
Returns a new DB::Object::NOT object, passing it whatever arguments were
provided.
NULL
Returns a "NULL" string to be used in queries.
on_conflict
The SQL "ON CONFLICT" clause needs to be implemented by the driver and
is currently supported only by and DB::Object::Postgres and
DB::Object::SQLite.
OR
Returns a new DB::Object::OR object, passing it whatever arguments were
provided.
order
This is a convenient wrapper around "order" in DB::Object::Query
Prepares the "ORDER BY" clause and returns the value of the clause in
list context or the "ORDER BY" clause in full in scalar context, ie.
"ORDER BY $clause"
param
If only a single parameter is provided, its value is return. If a list
of parameters is provided they are set accordingly using the "SET" sql
command.
Supported parameters are:
AUTOCOMMIT
INSERT_ID
LAST_INSERT_ID
SQL_AUTO_IS_NULL
SQL_BIG_SELECTS
SQL_BIG_TABLES
SQL_BUFFER_RESULT
SQL_LOG_OFF
SQL_LOW_PRIORITY_UPDATES
SQL_MAX_JOIN_SIZE
SQL_SAFE_MODE
SQL_SELECT_LIMIT
SQL_LOG_UPDATE
TIMESTAMP
If unsupported parameters are provided, they are considered to be
private and not passed to the database handler.
It then execute the query and return "undef" in perlfunc in case of
error.
Otherwise, it returns the current object used to call the method.
passwd
Sets or gets the "passwd" property for this database object.
ping
Evals a SELECT 1 statement and returns 0 if errors occurred or the
return value.
ping_select
Will prepare and execute a simple "SELECT 1" and return 0 upon failure
or return the value returned from calling "execute" in DBI.
port
Sets or gets the "port" property for this database object.
prepare
Provided with a sql query and some hash reference of options and this
will prepare the query using the options provided. The options are the
same as the one in "prepare" in DBI method.
It returns a DB::Object::Statement object upon success or undef if an
error occurred. The error can then be retrieved using "errstr" or
"error".
prepare_cached
Same as "prepare" except the query is cached.
query
It prepares and executes the given SQL query with the options provided
and return "undef" in perlfunc upon error or the statement handler upon
success.
quote
This is used to properly format data by surrounding them with quotes or
not.
Calls "quote" in DBI and pass it whatever argument was provided.
replace
Just like for the "INSERT" query, "replace" takes one optional argument
representing a DB::Object::Statement "SELECT" object or a list of
field-value pairs.
If a "SELECT" statement is provided, it will be used to construct a
query of the type of "REPLACE INTO mytable SELECT FROM other_table"
Otherwise the query will be "REPLACE INTO mytable (fields)
VALUES(values)"
In scalar context, it execute the query and in list context it simply
returns the statement handler.
reset
This is used to reset a prepared query to its default values. If a field
is a date/time type, its default value will be set to NOW()
It execute an update with the reseted value and return the number of
affected rows.
returning
The SQL "RETURNING" clause needs to be implemented by the driver and is
currently supported only by and DB::Object::Postgres and
DB::Object::SQLite.
reverse
Get or set the reverse mode.
select
Given an optional list of fields to fetch, "select" prepares a "SELECT"
query.
If no field was provided, "select" will use default value where
appropriate like the "NOW()" for date/time fields.
"select" calls upon "tie", "where", "group", "order", "limit" and
"local" to build the query.
In scalar context, it execute the query and return it. In list context,
it just returns the statement handler.
set
Provided with variable and this will issue a query to "SET" the given
SQL variable.
If any error occurred, undef will be returned and an error set,
otherwise it returns true.
sort
It toggles sort mode on and consequently disable reverse mode.
stat
Issue a "SHOW STATUS" query and if a particular $type is provided, it
will return its value if it exists, otherwise it will return "undef" in
perlfunc.
In absence of particular $type provided, it returns the hash list of
values returns or a reference to the hash list in scalar context.
state
Queries the DBI state and return its value.
supported_class
Returns the list of driver packages such as DB::Object::Postgres
supported_drivers
Returns the list of driver name such as Pg
table
Given a table name, "table" will return a DB::Object::Tables object. The
object is cached for re-use.
table_exists
Provided with a table name and this returns true if the table exist or
false otherwise.
table_info
This is a method that must be implemented by the driver package.
table_push
Add the given table name to the stack of cached table names.
tables
Connects to the database and finds out the list of all available tables.
If cache is available, it will use it instead of querying the database
server.
Returns undef or empty list in scalar or list context respectively if no
table found.
Otherwise, it returns the list of table in list context or a reference
of it in scalar context.
tables_cache
Returns the table cache object
tables_info
This is a method that must be implemented by the driver package.
tables_refresh
Rebuild the list of available database table.
Returns the list of table in list context or a reference of it in scalar
context.
tie
This is a convenient wrapper around "tie" in DB::Object::Query
TRUE
Returns "TRUE" to be used in queries.
unix_timestamp
This is a convenient wrapper around "unix_timestamp" in
DB::Object::Query
unlock
This is a convenient wrapper around "unlock" in DB::Object::Query
update
Given a list of field-value pairs, update prepares a sql update query.
It calls upon where and limit as previously set.
It returns undef and sets an error if it failed to prepare the update
statement. In scalar context, it execute the query. In list context, it
simply return the statement handler.
use
Given a database, it switch to it, but before it checks that the
database exists. If the database is different than the current one, it
sets the *multi_db* parameter, which will have the fields in the queries
be prefixed by their respective database name.
It returns the database handler.
use_cache
Provided with a boolean value and this sets or get the *use_cache*
parameter.
use_bind
Provided with a boolean value and this sets or get the *use_cache*
parameter.
variables
Query the SQL variable $type
It returns a blank string if nothing was found, or the value found.
version
This is a method that must be implemented by the driver package.
where
This is a convenient wrapper around "where" in DB::Object::Query
_cache_this
Provided with a query, this will cache it for future re-use.
It does some check and maintenance job to ensure the cache does not get
too big whenever it exceed the value of $CACHE_SIZE set in the main
config file.
It returns the cached statement as an DB::Object::Statement object.
_check_connect_param
Provided with an hash reference of connection parameters, this will get
the valid parameters by calling "_connection_parameters" and the
connection default options by calling "_connection_options"
It returns the connection parameters hash reference.
_check_default_option
Provided with an hash reference of options, and it actually returns it,
so this does not do much, because this method is supposed to be
supereded by the driver package.
_connection_options
Provided with an hash reference of connection parameters and this will
returns an hash reference of options whose keys match the regular
expression "/^[A-Z][a-zA-Z]+/"
So this does not do much, because this method is supposed to be
superseded by the driver package.
_connection_parameters
Returns an array reference containing the following keys: db login
passwd host port driver database server opt uri debug
_connection_params2hash
Provided with an hash reference of connection parameters and this will
check if the following environment variables exists and if so use them:
"DB_NAME", "DB_LOGIN", "DB_PASSWD", "DB_HOST", "DB_PORT", "DB_DRIVER",
"DB_SCHEMA"
If the parameter property *uri* was provided of if the environment
variable "DB_CON_URI" is set, it will use this connection uri to get the
necessary connection parameters values.
An URI could be "http://localhost:5432?database=somedb" or
"file:/foo/bar?opt={"RaiseError":true}"
Alternatively, if the connection parameter *conf_file* is provided then
its json content will be read and decoded into an hash reference.
The following keys can be used in the json data in the *conf_file*:
"database", "login", "passwd", "host", "port", "driver", "schema", "opt"
The port can be specified in the *host* parameter by separating it with
a semicolon such as "localhost:5432"
The *opt* parameter can Alternatively be provided through the
environment variable "DB_OPT"
It returns the hash reference of connection parameters.
_clean_statement
Given a query string or a reference to it, it cleans the statement by
removing leading and trailing space before and after line breaks.
It returns the cleaned up query as a string if the original query was
provided as a scalar reference.
_convert_datetime2object
Provided with an hash or hash reference of options and this will simply
return the *data* property.
This does not do anything meaningful, because it is supposed to be
superseded by the diver package.
_convert_json2hash
Provided with an hash or hash reference of options and this will simply
return the *data* property.
This does not do anything meaningful, because it is supposed to be
superseded by the diver package.
_dbi_connect
This will call "_dsn" which must exist in the driver package, and based
on the "dsn" received, this will initiate a "connect_cache" in DBI if
the object property "cache_connections" has a true value, or simply a
"connect" in DBI otherwise.
It returns the database handler.
_decode_json
Provided with some json data and this will decode it using JSON and
return the associated hash reference or "undef" in perlfunc if an error
occurred.
_dsn
This will die complaining the driver has not implemented this method,
unless the driver did implement it.
_encode_json
Provided with an hash reference and this will encode it into a json
string and return it.
_make_sth
Given a package name and a hash reference, this builds a statement
object with all the necessary parameters.
It also sets the query time to the current time with the parameter
*query_time*
It returns an object of the given $package.
_param2hash
Provided with some hash reference parameters and this will simply return
it, so it does not do anything meaningful.
This is supposed to be superseded by the driver package.
_process_limit
A convenient wrapper around the "_process_limit" in DB::Object::Query
_query_object_add
Provided with a DB::Object::Query and this will add it to the current
object property *query_object* and return it.
_query_object_create
This is supposed to be called from a DB::Object::Tables
Create a new DB::Object::Query object, sets the *debug* and *verbose*
values and sets its property "table_object" in DB::Object::Query to the
value of the current object.
_query_object_current
Returns the current *query_object*
_query_object_get_or_create
Check to see if the "query_object" is already set and then return its
value, otherwise create a new object by calling "_query_object_create"
and return it.
_query_object_remove
Provided with a DB::Object::Query and this will remove it from the
current object property *query_object*.
It returns the object removed.
_reset_query
If this has not already been reset, this will mark the current query
object as reset and calls "_query_object_remove" and return the value
for "_query_object_get_or_create"
If it has been already reset, this will return the value for
"_query_object_current"
OPERATORS
AND( VALUES )
Given a value, this returns a DB::Object::AND object. You can retrieve
the value with "value" in DB::Object::AND
This is used by "where"
my $op = $dbh->AND( login => 'joe', status => 'active' );
# will produce:
WHERE login = 'joe' AND status = 'active'
NOT( VALUES )
Given a value, this returns a DB::Object::NOT object. You can retrieve
the value with "value" in DB::Object::NOT
This is used by "where"
my $op = $dbh->AND( login => 'joe', status => $dbh->NOT( 'active' ) );
# will produce:
WHERE login = 'joe' AND status != 'active'
OR( VALUES )
Given a value, this returns a DB::Object::OR object. You can retrieve
the value with "value" in DB::Object::OR
This is used by "where"
my $op = $dbh->OR( login => 'joe', login => 'john' );
# will produce:
WHERE login = 'joe' OR login = 'john'
SEE ALSO
DBI, Apache::DBI
AUTHOR
Jacques Deguest <jack@deguest.jp>
COPYRIGHT & LICENSE
Copyright (c) 2019-2021 DEGUEST Pte. Ltd.
You can use, copy, modify and redistribute this package and associated
files under the same terms as Perl itself.