SQL::Eval(3)						User Contributed Perl Documentation					      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 concrete 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 0
		   $eval->param(0);		 # Get parameter 0

       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 current 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 implemented 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 column 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 written. 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 serialized 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

       All rights reserved.

       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.

SEE ALSO

       SQL::Statement(3)

perl v5.12.1							    2010-05-06							      SQL::Eval(3)