sql::eval(3)

NAME

SQL::Eval - Base for deriving evalution objects for
SQL::Statement

SYNOPSIS

require SQL::Statement;
require SQL::Eval;
# Create an SQL statement; use a concrete subclass of
# SQL::Statement
my $stmt = MyStatement->new("SELECT * FROM foo, bar",
                            SQL::Parser->new('Ansi'));
# Get an eval object by calling open_tables; this
# will call MyStatement::open_table
my $eval = $stmt->open_tables($data);
# Set parameter 0 to 'Van Gogh'
$eval->param(0, 'Van Gogh');
# Get parameter 2
my $param = $eval->param(2);
#  Get the SQL::Eval::Table object referring the 'foo'
table
my $fooTable = $eval->table('foo');

DESCRIPTION

This module implements two classes that can be used for
deriving concrete subclasses to evaluate SQL::Statement
objects. The SQL::Eval object can be thought as an
abstract state engine for executing SQL queries, the
SQL::Eval::Table object can be considered a *very* table
abstraction. It implements method for fetching or storing
rows, retrieving column names and numbers and so on. See
the "test.pl" script as an example for implementing a con
crete subclass.

While reading on, keep in mind that these are abstract
classes, you *must* implement at least some of the methods
describe below. Even more, you need not derive from
SQL::Eval or SQL::Eval::Table, you just need to implement
the method interface.

All methods just throw a Perl exception in case of errors.

Method interface of SQL::Eval

new Constructor; use it like this:: $eval = SQL::Eval->new(attr);
Blesses the hash ref attr into the SQL::Eval class (or a subclass).
param Used for getting or setting input parameters, as: in the SQL query

INSERT INTO foo VALUES (?, ?);; Example:

$eval->param(0, $val); # Set parameter

$eval->param(0); # Get parameter
params Likewise used for getting or setting the complete: array of input parameters. Example:

$eval->params($params); # Set the array
$eval->params(); # Get the array
table Returns or sets a table object. Example:: $eval->table('foo', $fooTable); # Set the; 'foo' table object
$eval->table('foo'); # Return the; 'foo' table object
column Return the value of a column with a given name;: example:

$col = $eval->column('foo', 'id'); # Return

the 'id' column of
# the cur

rent row in the
# 'foo'

table
This is equivalent and just a shorthand for: $col = $eval->table('foo')->column('id');
Method interface of SQL::Eval::Table
new Constructor; use it like this:: $eval = SQL::Eval::Table->new(attr);
Blesses the hash ref attr into the SQL::Eval::Table class (or a subclass).
row Used to get the current row as an array ref. Do: not mismatch getting the current row with the
fetch_row method! In fact this method is valid
only after a successfull "$table->fetchrow()".
Example:

$row = $table->row();
column Get the column with a given name in the current: row. Valid only after a successfull
"$table->fetchrow()". Example:

$col = $table->column($colName);
column_num: Return the number of the given column name. Column
numbers start with 0. Returns undef, if a column
name is not defined, so that you can well use this
for verifying valid column names. Example:

$colNum = $table->column_num($colNum);
column_names: Returns an array ref of column names.
The above methods are implemented by SQL::Eval::Table. The following methods aren't, so that they *must* be imple mented by concrete subclassed. See the "test.pl" script for example.
fetch_row: Fetches the next row from the table. Returns
"undef", if the last row was already fetched. The
argument $data is for private use of the concrete
subclass. Example:

$row = $table->fetch_row($data);; Note, that you may use

$row = $table->row();; for retrieving the same row again, until the next
call of "fetch_row".
push_row: Likewise for storing rows. Example:

$table->push_row($data, $row);
push_names: Used by the CREATE TABLE statement to set the col umn names of the new table. Receives an array ref
of names. Example:

$table->push_names($data, $names);
seek Similar to the seek method of a filehandle; used: for setting the number of the next row being writ
ten. Example:

$table->seek($data, $whence, $rowNum);; Actually the current implementation is using only
"seek($data, 0,0)" (first row) and "seek($data,
2,0)" (last row, end of file).
truncate: Truncates a table after the current row. Example:

$table->truncate($data);

INTERNALS

The current implementation is quite simple: An SQL::Eval
object is an hash ref with only two attributes. The
"params" attribute is an array ref of parameters. The
"tables" attribute is an hash ref of table names (keys)
and table objects (values).

SQL::Eval::Table instances are implemented as hash refs.
Used attributes are "row" (the array ref of the current
row), "col_nums" (an hash ref of column names as keys and
column numbers as values) and "col_names", an array ref of
column names with the column numbers as indexes.

MULTITHREADING

All methods are working with instance-local data only,
thus the module is reentrant and thread safe, if you
either don't share handles between threads or grant seri
alized use.

AUTHOR AND COPYRIGHT

This module is Copyright (C) 1998 by: Jochen Wiedmann
Am Eisteich 9
72555 Metzingen
Germany; Email: joe@ispsoft.de
Phone: +49 7123 14887
You may distribute this module under the terms of either the GNU General Public License or the Artistic License, as specified in the Perl README file.

docs.sk

comprehensive documentation repository

Most Viewed