The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.


Data::ObjectDriver::SQL - an SQL statement


    my $sql = Data::ObjectDriver::SQL->new();
    $sql->select([ 'id', 'name', 'bucket_id', 'note_id' ]);
    $sql->from([ 'foo' ]);
    $sql->add_where('name',      'fred');
    $sql->add_where('bucket_id', { op => '!=', value => 47 });
    $sql->add_where('note_id',   \'IS NULL');

    my $sth = $dbh->prepare($sql->as_sql);
    $sth->execute(@{ $sql->{bind} });
    my @values = $sth->selectrow_array();

    my $obj = SomeObject->new();


Data::ObjectDriver::SQL represents an SQL statement. SQL statements are used internally to Data::ObjectDriver::Driver::DBI object drivers to convert database operations (search(), update(), etc) into database operations, but sometimes you just gotta use SQL.


Data::ObjectDriver::SQL sports several data attributes that represent the parts of the modeled SQL statement. These attributes all have accessor and mutator methods. Note that some attributes have more convenient methods of modification (for example, add_where() for the where attribute).

select (arrayref)

The database columns to select in a SELECT query.

distinct (boolean)

Whether the SELECT query should return DISTINCT rows only.

select_map (hashref)

The map of database column names to object fields in a SELECT query. Use this mapping to convert members of the select list to column names.

select_map_reverse (hashref)

The map of object fields to database column names in a SELECT query. Use this map to reverse the select_map mapping where needed.

from (arrayref)

The list of tables from which to query results in a SELECT query.

Note if you perform a SELECT query with multiple tables, the rows will be selected as Cartesian products that you'll need to reduce with WHERE clauses. Your query might be better served with real joins specified through the joins attribute of your statement.

joins (arrayref of hashrefs containing scalars and hashrefs)

The list of JOIN clauses to use in the table list of the statement. Each clause is a hashref containing these members:

  • table

    The name of the table in from being joined.

  • joins (arrayref)

    The list of joins to perform on the table named in table. Each member of joins is a hashref containing:

    • type

      The type of join to use. That is, the SQL string to use before the word JOIN in the join expression; for example, INNER or NATURAL RIGHT OUTER). This member is optional. When not specified, the default plain JOIN join is specified.

    • table

      The name of the table to which to join.

    • condition

      The SQL expression across which to perform the join, as a string.

where (arrayref)

The list of WHERE clauses that apply to the SQL statement. Individual members of the list are strings of SQL. All members of this attribute must be true for a record to be included as a result; that is, the list members are ANDed together to form the full WHERE clause.

where_values (hashref of variant structures)

The set of data structures used to generate the WHERE clause SQL found in the where attributes, keyed on the associated column names.

bind (arrayref)

The list of values to bind to the query when performed. That is, the list of values to be replaced for the ?es in the SQL.

limit (scalar)

The maximum number of results on which to perform the query.

offset (scalar)

The number of records to skip before performing the query. Combined with a limit and application logic to increase the offset in subsequent queries, you can paginate a set of records with a moving window containing limit records.

group (hashref, or an arrayref of hashrefs)

The fields on which to group the results. Grouping fields are hashrefs containing these members:

  • column

    Name of the column on which to group.

Note you can set a single grouping field, or use an arrayref containing multiple grouping fields.

having (arrayref)

The list of clauses to specify in the HAVING portion of a GROUP ... HAVING clause. Individual clauses are simple strings containing the conditional expression, as in where.

order (hashref, or an arrayref of hashrefs)

Returns or sets the fields by which to order the results. Ordering fields are hashrefs containing these members:

  • column

    Name of the column by which to order.

  • desc

    The SQL keyword to use to specify the ordering. For example, use DESC to specify a descending order. This member is optional.

Note you can set a single ordering field, or use an arrayref containing multiple ordering fields.

$sql->comment([ $comment ])

Returns or sets a simple comment to the SQL statement



Creates a new, empty SQL statement.

$sql->add_select($column [, $term ])

Adds the database column $column to the list of fields to return in a SELECT query. The requested object member will be indicated to be $term in the statement's select_map and select_map_reverse attributes.

$term is optional, and defaults to the same value as $column.

$sql->add_join($table, \@joins)

Adds the join statement indicated by $table and \@joins to the list of JOIN table references for the statement. The structure for the set of joins are as described for the joins attribute member above.

$sql->add_index_hint($table, $index)

Specifies a particular index to use for a particular table.

$sql->add_where($column, $value)

Adds a condition on the value of the database column $column to the statement's WHERE clause. A record will be tested against the below conditions according to what type of data structure $value is:

  • a scalar

    The value of $column must equal $value.

  • a reference to a scalar

    The value of $column must evaluate true against the SQL given in $$value. For example, if $$value were IS NULL, $column must be NULL for a record to pass.

  • a hashref

    The value of $column must compare against the condition represented by $value, which can contain the members:

    • value

      The value with which to compare (required).

    • op

      The SQL operator with which to compare value and the value of $column (required).

    • column

      The column name for the comparison. If this is present, it overrides the column name $column, allowing you to build more complex conditions like ((foo = 1 AND bar = 2) OR (baz = 3)).

    For example, if value were NULL and op were IS, a record's $column column would have to be NULL to match.

  • an arrayref of scalars

    The value of $column may equal any of the members of @$value. The generated SQL performs the comparison with as an IN expression.

  • an arrayref of (mostly) references

    The value of $column must compare against any of the expressions represented in @$value. Each member of the list can be any of the structures described here as possible forms of $value.

    If the first member of the @$value array is the scalar string -and, all subsequent members of <@$value> must be met for the record to match. Note this is not very useful unless contained as one option of a larger OR alternation.

All individual conditions specified with add_where() must be true for a record to be a result of the query.

Beware that you can create a circular reference that will recursively generate an infinite SQL statement (for example, by specifying a arrayref $value that itself contains $value). As add_where() evaluates your expressions before storing the conditions in the where attribute as a generated SQL string, this will occur when calling add_where(), not as_sql(). So don't do that.


This method accepts an array reference of clauses that are glued together with logical operators. With it, you can express where clauses that mix logical operators together to produce more complex queries. For instance:

    [ { foo => 1, bar => 2 }, -or => { baz => 3 } ]

The values given for the columns support all the variants documented for the add_where() method above. Logical operators used inbetween the hashref elements can be one of: '-or', '-and', '-or_not', '-and_not'.

$sql->has_where($column, [$value])

Returns whether a where clause for the column $column was added to the statement with the add_where() method.

The $value argument is currently ignored.

$sql->add_having($column, $value)

Adds an expression to the HAVING portion of the statement's GROUP ... HAVING clause. The expression compares $column using $value, which can be any of the structures described above for the add_where() method.

$sql->add_index_hint($table, \@hints)

Addes the index hint into a SELECT query. The structure for the set of \@hints are arrayref of hashrefs containing these members:

  • type (scalar)

    The name of the type. "USE", "IGNORE or "FORCE".

  • list (arrayref)

    The list of name of indexes which to use.


Returns the SQL fully representing the SQL statement $sql.


Returns the SQL representing the HAVING portion of $sql's GROUP ... HAVING clause.


Returns the SQL representing $sql's WHERE clause.


Returns the SQL for the LIMIT ... OFFSET clause of the statement.


Returns the SQL representing the aggregation clause of type $set for the SQL statement $sql. Reasonable values of $set are ORDER and GROUP.


  • Invalid/unsafe column name column

    The column name you specified to add_where() contained characters that are not allowed in database column names. Only word characters and periods are allowed. Perhaps you didn't filter punctuation out of a generated column name correctly.


Data::ObjectDriver::SQL does not provide the functionality for turning SQL statements into instances of object classes.



Data::ObjectDriver is free software; you may redistribute it and/or modify it under the same terms as Perl itself.


Except where otherwise noted, Data::ObjectDriver is Copyright 2005-2006 Six Apart, All rights reserved.