Mark Lawrence > SQL-DB > SQL::DB

Download:
SQL-DB-0.971.0.tar.gz

Dependencies

Annotate this POD

CPAN RT

New  1
Open  2
View/Report Bugs
Module Version: 0.971.0   Source  

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 <nomad@null.net>

COPYRIGHT AND LICENSE ^

Copyright (C) 2007-2011 Mark Lawrence <nomad@null.net>

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.

syntax highlighting: