NAME SQL::DB - SQL database interface for Perl VERSION 0.971.0. Development release. SYNOPSIS use SQL::DB ':all'; my $db = SQL::DB->connect( 'dbi:...', 'username', 'password' ); # The very simple stuff my $success = $db->insert( into => 'actors', values => { id => 1, name => 'John Smith' }, ); my $count = $db->update( 'actors', set => { name => 'Jack Smith' }, where => { id => 1, name => 'John Smith' }, ); my $count = $db->delete( from => 'actors', where => { actor_id => 1, last_name => 'Jones' }, ); my $row = $db->select( [ 'id', 'name' ], from => 'actors', where => { id => 1 }, ); print $row->id . ':' . $row->name . "\n"; # The do-any-SQL-you-want stuff my $people = $db->irow('people'); $db->do( insert_into => $people->( 'id', 'name' ); sql_values( 1, 'A Name' ), ); # Anyone celebrating a birthday today gets a raise, with the # calculation done inside the database. my $people = $db->urow('people'); $db->do( update => $people, set => $people->salary( $people->salary * 2 ), where => $people->dob == $today, ); my $purchases = $db->srow('purchases'); my $row = $db->fetch1( select => [ $people->name, $ps->pid ], from => $people, left_join => $purchases, on => $purchases->id == $people->id, where => $people->id->in( 1, 2, 3 ) . AND . $people->name->like('%paul%'), limit => 1, offset => 1, ); # then do stuff with $row->pid, $row->name etc my @rows = $db->fetch( select => [ sql_coalesce( $p->pid, $p->cid )->as('pcid') ], from => $p, where => $p->cid->is_not_null, ); # coalesce column is available as $row->pcid my $iter = $db->iter( @query ... ); while ( my $row = $iter->next ) { print $row->column(), $row->some_other_column; } # If you want the data your own way you can still use the query # syntax: my $sth = $db->sth(@query); map { print join( ',', @$_ ) . "\n" } $sth->fetchall_arrayref; # Transactions provided by DBIx::Connector $db->txn( sub { # multiple statements } ); DESCRIPTION SQL::DB is an extension to the Perl Database Interface (DBI). It is designed for complicated queries and efficient access to results. With an API that lets you easily write almost-raw SQL, SQL::DB gives you unfettered access to the power and flexibility of your underlying database. It aims to be a tool for programmers who want their databases to work just as hard as their Perl scripts. SQL::DB gives you access to aggregate expressions, joins, nested selects, unions and database-side operator invocations. Transactional support is provided via DBIx::Connector. Security conscious coders will be pleased to know that all user-supplied values are bound properly using DBI "bind_param()". Binding binary data is handled transparently across different database types. SQL::DB offers a couple of very simple Create, Retrieve, Update and Delete (CRUD) action methods. These are designed to get you up and running quickly when your query data is already inside a hash. The methods are abstractions of the real API, but should still read as much as possible like SQL. Although rows can be retrieved from the database as simple objects, SQL::DB does not attempt to be an Object-Relational-Mapper (ORM). There are no auto-inflating columns or automatic joins and the code size and speed reflect the lack of complexity. SQL::DB uses the light-weight Log::Any for logging. QUERY FORMAT An SQL::DB query is composed from a list of scalars, schema objects, expressions, and arrays as follows. Scalars Scalars are assumed to be SQL keywords and are accepted more or less unchanged (uppercased with underscores converted to spaces). Perl SQL ---- --- 'select' SELECT 'outer_join' OUTER JOIN Schema Objects and DELETE. A urow object maps to a table in the database. It has a method for each of the columns in the table which return column-objects. These column-objects in turn have further methods which map to various SQL statements. The table and column objects are used in positions as appropriate for their types. Perl SQL ---- --- $table table (for UPDATE statements) $table table0 (for SELECT statements) $table->col > 1 table0.col > ? $table->col->is_not_null table0.col IS NULL $table->col->asc table0.col ASC $table->col->between(1,5) table0.col BETWEEN(?,?) Expressions Expressions are built using schema objects (described below) that hold extra information such as table/column names and types, your application's input values, and their relationships. Perl SQL ---- --- $table->col == 1 table0.col = ? ($table->col == 1) .AND. ($table.col2 = ? $table->col > 1 table0.col > ? $table->col == table.col = $table->col2 - $table->col3 table.col2 - table.col3 Arrays Arrays (array-refs) can contain scalars and expressions which will appear in the final SQL joined together by commas (','). Perl SQL ---- --- select => [1,2,3] SELECT ?,?,? set => [$t->c1 == 1, $t->c2 == 2 ] SET t->c1 = ?, t.c2 = ? Functions Arrays (array-refs) can contain scalars and expressions which will appear in the final SQL joined together by commas (','). Perl SQL ---- --- sql_count($table->col) COUNT(table0.col) sql_values('a', 'b', 'c') VALUES(?,?,?) CONSTRUCTORS new( %args ) Connect to a database and return a new SQL::DB handle. Arguments are as follows: dsn The data source name ('dbi:...'). Required. username The database authentication username. password The database authentication password. attr A hash-reference of DBI handle attributes. RaiseError and AutoCommit are always set to 1 and cannot be overridden. PrintError defaults to 0. ChopBlanks defaults to 1. pg_enable_utf8, sqlite_unicode, and mysql_enable_utf8 default to 1. cache_sth Whether to use the DBI prepare_cached() method. See ATTRIBUTES below. table_info A reference to a hash containing the table information for the database. This is typically the value returned from an earlier call to the "deployed_table_info" method of SQL::DBx::Deploy. Use of this parameter is not necessary for SQL::DB applications, but could be an important optimisation to minimize database calls in applications with more than a trivial number of tables. This is more interesting for remote database engines such as PostgreSQL with a higher query latency than for local database engines such as SQLite. The standard usage scenario is as follows: After any change to the table/column structure of the database you can the save table information to a file: use SQL::DB; use SQL::DBx::Deploy; use YAML::Tiny; my $db = SQL::DB->connect(...); DumpFile('table_info.yaml', $db->deployed_table_info); Then in your application code you set the "table_info" parameter when you instantiate your SQL::DB object: package MyApp; use SQL::DB; use YAML::Tiny; my $db = SQL::DB->new( dsn => 'dbi:Pg:dbname=myapp', dbuser => 'username', dbpass => '******', table_info => LoadFile('table_info.yaml'), ); Now any calls to "urow" or "srow" on the $db object will not need to query the database to know the table structure. connect( $dsn, [ $username, $password, $attr ] ) This is a convenience wrapper around new() for those who prefer DBI-style construction. ATTRIBUTES conn -> DBIx::Connector The handle connecting us to the database. Read-only. dbd -> Str The database driver name (Pg, SQLite, etc). Read-only. schema -> SQL::DB::Schema The schema definition associated with this connection. Read-only. cache_sth <-> Bool If true then the DBI prepare_cached() method will be used for creating statement handles. Otherwise prepare() will be used. METHODS irows( @tables ) -> @coderef Returns coderefs for generating table/column strings. Calling the coderefs with column name arguments returns a string of the form 'table(col1,col2)'. These refs can be used with the do() method for INSERT queries. irow( $table ) => &coderef A singular/scalar version of "irows". urows( @tables ) -> @URow Returns schema objects representing database tables/rows for update-style SQL. These objects have a method for each table column. Each column object has the following methods: is_null(), is_not_null(), in(), not_in(), between(), not_between(), as(), like(), asc(), and desc() (see SQL::DB::Expr for details). These objects can be used with the do() method for UPDATE and DELETE queries. urow( $table ) => $SQL::DB::Expr A singular/scalar version of "urows". srows( @tables ) -> @SRow Returns schema objects representing database tables/rows for select-style SQL. These objects have a method for each table column. Each column object has the following methods: is_null(), is_not_null(), in(), not_in(), between(), not_between(), as(), like(), asc(), and desc() (see SQL::DB::Expr for details). These objects can be used with the do(), sth(), fetch(), fetch1(), and iter() methods for SELECT queries. srow( $table ) => $SQL::DB::Expr A singular/scalar version of "srows". prepare( @query ) -> ($sth, $query) Prepares @query using DBI prepare() and returns a DBI::st statement handle and the SQL::DB::Expr object representing the query. Croaks on error. You need to call execute() on the statement handle yourself afterwards. prepare_cached( @query ) -> ($sth, $query) Prepares @query using DBI prepare_cached() and returns a DBI::st statement handle and the SQL::DB::Expr object representing the query. Croaks on error. You need to call execute() on the statement handle yourself afterwards. do(@query) -> $count Prepares (a INSERT, UPDATE or DELETE) @query using either prepare() or prepare_cached() (depending on the "cache_sth" attribute) and execute()'s the associated DBI::st statement handle. Croaks on error. Returns the value of the execute() call. The result is typically the number of rows affected (but this is driver dependent). sth( @query ) -> DBI::st Prepares (a SELECT) @query using either prepare() or prepare_cached() (depending on the "cache_sth" attribute) then execute()s and returns the associated DBI::st statement handle. Croaks on error. This method is useful if you want to obtain the data with one of the DBI fetchrow_hashref(), fetchall_arrayref() etc methods. object(@query) -> $object Prepares (a SELECT) @query using either prepare() or prepare_cached() (depending on the "cache_sth" attribute) and execute()'s it. Croaks on error. Returns a single array-based object and closes the underlying statement handle. The object has accessor methods for each column selected. objects(@query) -> @objects Prepares (a SELECT) @query using either prepare() or prepare_cached() (depending on the "cache_sth" attribute) and execute()'s it. Croaks on error. Returns a list of array-based objects and closes the underlying statement handle. Each object has accessor methods for each column selected. Be aware that calling this method can consume large amounts of memory if there are lots of rows to be retrieved. Consider using iter() instead. fetch1 An alias for object(). fetch An alias for objects(). hash Same as for object() but returns a hashref instead. hashes Same as for objects() but returns hashrefs instead. array Same as for object() but returns an arrayref instead. arrays Same as for objects() but returns arrayrefs instead. iter( @query ) -> SQL::DB::Iter Prepares (a SELECT) @query using either prepare() or prepare_cached() (depending on the "cache_sth" attribute) and execute()'s it. Croaks on error. Returns a cursor/iteration object with next() and all() methods for retrieving array-based objects. Each object has accessor methods for each column selected. txn(&coderef) Runs the Perl code in &coderef as an SQL transaction. If &coderef does not raise any exceptions then the transaction is commited, otherwise it is rolled back. See DBIx::Connector for details. current_timestamp -> Str Returns the current UTC timestamp as a string in the form 'yyyy-mm-dd hh:mm:ssZ'. The same value is always returned during a transaction. query_as_string($sql, @bind_values) -> Str Pretty print an SQL query by inserting the bind values into the SQL itself. insert(into => $table, values => \%val) -> Int Insert a row into the database and return the number of rows affected. update($table, set => \%values, where => \%expr) -> Int Update rows in the database and return the number of rows affected. This method is retricted to the wholesale replacement of column values (no database-side calculations etc). Multiple WHERE key/values are only 'AND'd together. An 'undef' value maps to SQL's NULL value. delete(from => $table, where => \%expr) -> Int Delete rows from the database and return the number of rows affected. select(\@columns, from => $table, where => \%expr) -> @Obj Retrieve rows from the database as a list of objects in array context, or a single object in scalar context. These objects (blessed into a dynamically created class) have an accessor method for each column. The first argument to the select() method must be either an array reference of column names, or a single '*'. If the array reference is given only the columns specified will be retrieved from the database. CLASS FUNCTIONS The following functions can be exported individually or all at once using the ':all' tag. They all return an object which can be combined with or used inside other functions. bv( $value, [ $bind_type ] ) -> SQL::DB::BindValue This function returns an object which tells SQL::DB to bind $value using a placeholder. The optional $bind_type is a database type (integer, varchar, timestamp, bytea, etc) which will be converted to the appropriate bind constant during a prepare() or prepare_cached() call. query( @query ) -> SQL::DB::Expr Build an SQL query using a list of scalars, schema objects, expressions, other functions, and arrays. This function is the basis for the prepare(), prepare_cached(), do(), sth(), iter(), fetch() and fetch1() methods. sql_and( @args ) -> SQL::DB::Expr Maps to "$arg1 AND $arg2 AND ...". sql_case( @stmts ) -> SQL::DB::Expr Wraps @stmts inside a CASE/END pair while converting arguments to expressions where needed. sql_case( when => $actors->name->is_null, then => 'No Name', else => $actors->name, )->as('name') # CASE WHEN actors0.name IS NULL # THEN ? ELSE actors0.name END AS name sql_coalesce(@args) -> SQL::DB::Expr Maps to "COALESCE($arg1, $arg2, ...)". sql_cast($arg1, as => $arg2) -> SQL::DB::Expr Maps to "CAST( $arg1 AS $arg2 )". sql_concat(@args) -> SQL::DB::Expr Maps to "$arg1 || $arg2 || ...". sql_count(@args) -> SQL::DB::Expr Maps to "COUNT($arg1, $arg2, ...)". sql_exists(@args) -> SQL::DB::Expr Maps to "EXISTS(@args)". sql_func('myfunc', @args) -> SQL::DB::Expr Maps to "MYFUNC($arg1, $arg2, ...)". sql_hex(@args) -> SQL::DB::Expr Maps to "HEX($arg1, $arg2, ...)". sql_length(@args) -> SQL::DB::Expr Maps to "LENGTH(@args)". sql_lower(@args) -> SQL::DB::Expr Maps to "LOWER(@args)". sql_ltrim(@args) -> SQL::DB::Expr Maps to "LTRIM(@args)". sql_max(@args) -> SQL::DB::Expr Maps to "MAX(@args)". sql_min(@args) -> SQL::DB::Expr Maps to "MIN(@args)". sql_rtrim(@args) -> SQL::DB::Expr Maps to "RTRIM(@args)". sql_sum(@args) -> SQL::DB::Expr Maps to "MIN(@args)". sql_or(@args) -> SQL::DB::Expr Maps to "$arg1 OR $arg2 OR ...". sql_replace(@args) -> SQL::DB::Expr Maps to "REPLACE($arg1,$arg2 [,$arg3])". sql_substr(@args) -> SQL::DB::Expr Maps to "SUBSTR($arg1, $arg2, ...)". sql_table($name, @columns) -> SQL::DB::Expr Maps to "name(col1,col2,...)". sql_upper(@args) -> SQL::DB::Expr Maps to "UPPER(@args)". sql_values(@args) -> SQL::DB::Expr Maps to "VALUES($arg1, $arg2, ...)". COMPATABILITY All SQL::DB releases have so far been DEVELOPMENT! SQL::DB jumped from version 0.18 to 0.971.0 due to a complete rewrite based on Moo. Lots of things were simplified, modules deleted, dependencies removed, etc. The API changed enough to almost give this distribution a new name, except I don't know of anyone using this apart from myself. 0.971.0 will be the last release marked as development, 0.99 will be a release candidate, and 1.00 will be the first stable release. SEE ALSO DBIx::Connector, Log::Any SUPPORT SQL::DB is managed via Github: https://github.com/mlawren/sql-db/tree/devel SQL::DB follows a semantic versioning scheme: http://semver.org AUTHOR Mark Lawrence COPYRIGHT AND LICENSE Copyright (C) 2007-2011 Mark Lawrence This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.