Programming with SQL Relay using the Perl DBI API

Establishing a Session

To use SQL Relay, you have to identify the connection that you intend to use.

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

... execute some queries ...

$dbh->disconnect;

After calling the connect(), a session is established when the first execute() is run.

For the duration of the session, the client stays connected to a database connection daemon. While one client is connected, no other client can connect. Care should be taken to minimize the length of a session.

If you're using a transactional database, ending a session has a catch. Database connection daemons can be configured to send either a commit or rollback at the end of a session if DML queries were executed during the session with no commit or rollback. Program accordingly.

Executing Queries

Call prepare() and execute() to run a query.

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth=$dbh->prepare("select * from user_tables");

$sth->execute();

... process the result set ...

$dbh->disconnect;
Commits and Rollbacks

If you need to execute a commit or rollback, you should use the commit() and rollback() methods rather than sending a "commit" or "rollback" query. There are two reasons for this. First, it's much more efficient to call the methods. Second, if you're writing code that can run on transactional or non-transactional databases, some non-transactional databases will throw errors if they receive a "commit" or "rollback" query, but by calling the commit() and rollback() methods you instruct the database connection daemon to call the commit and rollback API methods for that database rather than issuing them as queries. If the API's have no commit or rollback methods, the calls do nothing and the database throws no error. This is especially important when using SQL Relay with ODBC.

You can also turn Autocommit on or off by setting the AutoCommit attribute of the database handle.

The following command turns Autocommit on.

$dbh->{AutoCommit} = 1;

The following command turns Autocommit off.

$dbh->{AutoCommit} = 0;

When Autocommit is on, the database performs a commit after each successful DML or DDL query. When Autocommit is off, the database commits when the client instructs it to, or (by default) when a client disconnects. For databases that don't support Autocommit, setting the AutoCommit attribute has no effect.

Temporary Tables

Some databases support temporary tables. That is, tables which are automatically dropped or truncated when an application closes it's connection to the database or when a transaction is committed or rolled back.

For databases which drop or truncate tables when a transaction is committed or rolled back, temporary tables work naturally.

However, for databases which drop or truncate tables when an application closes it's connection to the database, there is an issue. Since SQL Relay maintains persistent database connections, when an application disconnects from SQL Relay, the connection between SQL Relay and the database remains, so the database does not know to drop or truncate the table. To remedy this situation, SQL Relay parses each query to see if it created a temporary table, keeps a list of temporary tables and drops (or truncates them) when the application disconnects from SQL Relay. Since each database has slightly different syntax for creating a temporary table, SQL Relay parses each query according to the rules for that database.

In effect, temporary tables should work when an application connects to SQL Relay in the same manner that they would work if the application connected directly to the database.

Catching Errors

If your calls to connect(), prepare() or execute() fail, you can catch the error in DBI->errstr.

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword")
        or die DBI->errstr;

my $sth=$dbh->prepare("select * from user_tables")
        or die DBI->errstr;

$sth->execute()
        or die DBI->errstr;

... process the result set ...

$dbh->disconnect;
Bind Variables

Programs rarely execute fixed queries. More often than not, some part of the query is dynamically generated. The Perl DBI API provides means for using bind variables in those queries.

For a detailed discussion of binds, see this document.

Here is an example using the bind_param() function. The first parameter of the bind_param() function corresponds to the name or position of the bind variable.

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth=$dbh->prepare("select * from my_table where col1=:1 and col2=:2 and col3=:3");

$sth->bind_param(1,"hello");
$sth->bind_param(2,1);
$sth->bind_param(3,5.5);

$sth->execute();

... process the result set ...

$dbh->disconnect;

bind_param() is used for input binds. bind_inout_param() is used for output binds. Here is an example using the bind_inout_param() function to retrieve a value from a query. The first parameter of a bind_inout_param() call is the name or position of the bind variable, the second parameter is the local variable to return the result in and the third variable is the size of the buffer to reserve for the value.

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth=$dbh->prepare("begin; :1='hello'; :2=1; :3=5.5; end;");

my $hello;
my $integer;
my $float;
$sth->bind_inout_param(1,\$hello,10);
$sth->bind_inout_param(2,\$integer,10);
$sth->bind_inout_param(3,\$float,10);

$sth->execute();

print("$hello $integer $float\n");

$dbh->disconnect;

Here is an example using the execute() function directly. The additional parameters correspond to bind variable positions. Note that the first parameter must be "undef".

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth=$dbh->prepare("select * from my_table where col1=:0 and col2=:1 and col3=:2");

$sth->execute(undef,"hello",1,5.5);

... process the result set ...

$dbh->disconnect;
Re-Binding and Re-Execution

A feature of the prepare/bind/execute paradigm is the ability to prepare, bind and execute a query once, then re-bind and re-execute the query over and over without re-preparing it. If your backend database natively supports this paradigm, you can reap a substantial performance improvement.

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth=$dbh->prepare("select * from my_table where col1=:0 and col2=:1 and col3=:2");

$sth->execute(undef,"hello",1,1.1);

... process result set ...

$sth->execute(undef,"hi",2,2.2);

... process result set ...

$sth->execute(undef,"goodbye",3,3.3);

... process result set ...

$dbh->disconnect;
Accessing Fields in the Result Set

The fetchrow_array(), bind_columns() and fetch() functions are useful for processing result sets. fetchrow_array() returns an array of values. bind_columns() associates variables with columns which are set when fetch() is called.

Here's an example using fetchrow_array().

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth=$dbh->prepare("select * from user_tables");

$sth->execute();

while (@data=$sth->fetchrow_array()) {
        
        foreach $col (@data) {
                print "\"$col\",";
        }
        print "\n";
}

$dbh->disconnect;

Here's an example using bind_columns() and fetch(). Note that the first bind_columns() parameter must be "undef".

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth=$dbh->prepare("select * from my_table");

$sth->execute();
$sth->bind_columns(undef,\$col1,\$col2,\$col3,\$col4);

while ($sth->fetch()) {
        print "$col, $col2, $col3, $col4\n";
}

$dbh->disconnect;
Cursors

Cursors make it possible to execute queries while processing the result set of another query. You can select rows from a table in one query, then iterate through it's result set, inserting rows into another table, using only 1 database connection for both operations.

For example:

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth1=$dbh->prepare("select * from my_first_table");

$sth1->execute();
$sth1->bind_columns(undef,\$col1,\$col2,\$col3);

while ($sth1->fetch()) {
        my $sth2=$dbh->prepare("insert into my_second_table values (:0, :1, :2, sysdate)");
        $sth2->execute(undef,$col1,$col2,$col3);
}

$dbh->disconnect;
Getting Column Information

After executing a query, the column count is stored in the NUMBER_OF_FIELDS statement property and column names are stored in the NAME statement property. They are accessible as follows:

#!/usr/bin/env perl

use DBI;

my $dbh=DBI->connect("DBI:SQLRelay:host=testhost;port=9000;socket=","testuser","testpassword");

my $sth=$dbh->prepare("select * from my_table");

$sth->execute();

for ($i=1; $i<=$sth->{NUM_OF_FIELDS}; $i++) {
       print "Column $i: $sth->{NAME}->[i-1]\n";
}

$dbh->disconnect;
Stored Procedures

Many databases support stored procedures. Stored procedures are sets of queries and procedural code that are executed inside of the database itself. For example, a stored procedure may select rows from one table, iterate through the result set and, based on the values in each row, insert, update or delete rows in other tables. A client program could do this as well, but a stored procedure is generally more efficient because queries and result sets don't have to be sent back and forth between the client and database. Also, stored procedures are generally stored in the database in a compiled state, while queries may have to be re-parsed and re-compiled each time they are sent.

While many databases support stored procedures. The syntax for creating and executing stored procedures varies greatly between databases.

SQL Relay supports stored procedures for most databases, but there are some caveats. Stored procedures are not currently supported when using FreeTDS against Sybase or Microsoft SQL Server. Blob/Clob bind variables are only supported in Oracle 8i or higher. Sybase stored procedures must use varchar output parameters.

Stored procedures typically take input paramters from client programs through input bind variables and return values back to client programs either through bind variables or result sets. Stored procedures can be broken down into several categories, based on the values that they return. Some stored procedures don't return any values, some return a single value, some return multiple values and some return entire result sets.

No Values

Some stored procedures don't return any values. Below are examples, illustrating how to create, execute and drop this kind of stored procedure for each database that SQL Relay supports.

Oracle

To create the stored procedure, run a query like the following.

create procedure testproc(in1 in number, in2 in number, in3 in varchar2) is
begin
        insert into mytable values (in1,in2,in3);
end;

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth->$dbh->prepare("begin testproc(:in1,:in2,:in3); end;");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,2,1);
$sth->bind_param("in3","hello");
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
Sybase and Microsoft SQL Server

To create the stored procedure, run a query like the following.

create procedure testproc @in1 int, @in2 float, @in3 varchar(20) as
        insert into mytable values (@in1,@in2,@in3)

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth->$dbh->prepare("exec testproc");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,2,1);
$sth->bind_param("in3","hello");
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
Interbase and Firebird

To create the stored procedure, run a query like the following.

create procedure testproc(in1 integer, in2 float, in3 varchar(20)) as
begin
        insert into mytable values (in1,in2,in3);
        suspend;
end;

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("execute procedure testproc ?, ?, ?");
$sth->bind_param("1",1);
$sth->bind_param("2",1.1,2,1);
$sth->bind_param("3","hello");
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
DB2

To create the stored procedure, run a query like the following.

create procedure testproc(in in1 int, in in2 double, in in3 varchar(20)) language sql
begin
        insert into mytable values (in1,in2,in3);
end;

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("call testproc(?,?,?)");
$sth->bind_param("1",1);
$sth->bind_param("2",1.1,2,1);
$sth->bind_param("3","hello");
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
Postgresql

To create the stored procedure, run a query like the following.

create function testproc(int,float,varchar(20)) returns void as '
begin
        insert into mytable values ($1,$2,$3);
        return;
end;' language plpgsql

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("select testproc(:in1,:in2,:in3)");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,2,1);
$sth->bind_param("in3","hello");
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc

Single Values

Some stored procedures return single values. Below are examples, illustrating how to create, execute and drop this kind of stored procedure for each database that SQL Relay supports.

Oracle

In Oracle, stored procedures can return values through output parameters or as return values of the procedure itself.

Here is an example where the procedure itself returns a value. Note that Oracle calls these functions.

To create the stored procedure, run a query like the following.

create function testproc(in1 in number, in2 in number, in3 in varchar2) returns number is
begin
        return in1;
end;

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("select testproc(:in1,:in2,:in3) from dual");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,2,1);
$sth->bind_param("in3","hello");
$sth->execute();
my $result;
$sth->bind_columns(undef,\$result);
$sth->fetch();

To drop the stored procedure, run a query like the following.

drop function testproc

Here is an example where the value is returned through an output parameter.

To create the stored procedure, run a query like the following.

create procedure testproc(in1 in number, in2 in number, in3 in varchar2, out1 out number) as
begin
        out1:=in1;
end;

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("begin testproc(:in1,:in2,:in3,:out1); end;");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,2,1);
$sth->bind_param("in3","hello");
my $result;
$sth->bind_inout_param("out1",\$result,20);
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
Sybase and Microsoft SQL Server

In Sybase and Microsoft SQL Server, stored procedures return values through output parameters rather than as return values of the procedure itself.

To create the stored procedure, run a query like the following.

create procedure testproc @in1 int, @in2 float, @in3 varchar(20), @out1 int output as
        select @out1=convert(varchar(20),@in1)

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dth->prepare("exec testproc");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,2,1);
$sth->bind_param("in3","hello");
my $result;
$sth->bind_inout_param("out1",\$result,20);
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
Interbase and Firebird

To create the stored procedure, run a query like the following.

create procedure testproc(in1 integer, in2 float, in3 varchar(20)) returns (out1 integer) as
begin
        out1=in1;
        suspend;
end;

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dth->prepare("select * from testproc(?,?,?)");
$sth->bind_param("1",1);
$sth->bind_param("2",1.1,2,1);
$sth->bind_param("3","hello");
$sth->execute();
my $result;
$sth->bind_columns(undef,\$result);
$sth->fetch();

Alternatively, you can run a query like the following and receive the result using an output bind variable. Note that in Interbase/Firebird, input and output bind variable indices are distict from one another. The index of the output bind variable is 1 rather than 4, even though there were 3 input bind variables.

my $sth=$dbh->prepare("execute procedure testproc ?, ?, ?");
$sth->bind_param("1",1);
$sth->bind_param("2",1.1,2,1);
$sth->bind_param("3","hello");
my $result;
$sth->bind_inout_param("1",\$result,20);
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
DB2

In DB2, stored procedures return values through output parameters rather than as return values of the procedure itself.

To create the stored procedure, run a query like the following.

create procedure testproc(in in1 int, in in2 double, in in3 varchar(20), out out1 int) language sql
begin
        set out1 = in1;
end

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("call testproc(?,?,?,?)");
$sth->bind_param("1",1);
$sth->bind_param("2",1.1,2,1);
$sth->bind_param("3","hello");
my $result;
$sth->bind_inout_param("4",\$result,25);
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
Postgresql

To create the stored procedure, run a query like the following.

create function testfunc(int,float,char(20)) returns int as '
declare
        in1 int;
        in2 float;
        in3 char(20);
begin
        in1:=$1;
        return;
end;
' language plpgsql

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("select * from testfunc(:in1,:in2,:in3)");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,4,2);
$sth->bind_param("in3","hello");
$sth->execute();
my $result;
$sth->bind_columns(undef,\$result);
$sth->fetch();

To drop the stored procedure, run a query like the following.

drop function testfunc(int,float,char(20))

Multiple Values

Some stored procedures return multiple values. Below are examples, illustrating how to create, execute and drop this kind of stored procedure for each database that SQL Relay supports.

Oracle

In Oracle, stored procedures can return values through output parameters or as return values of the procedure itself. If a procedure needs to return multiple values, it can return one of them as the return value of the procedure itself, but the rest must be returned through output parameters.

To create the stored procedure, run a query like the following.

create procedure testproc(in1 in number, in2 in number, in3 in varchar2, out1 out number, out2 out number, out3 out varchar2) is
begin
        out1:=in1;
        out2:=in2;
        out3:=in3;
end;

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("begin testproc(:in1,:in2,:in3,:out1,:out2,:out3); end;");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,2,1);
$sth->bind_param("in3","hello");
my $out1;
my $out2;
my $out3;
$sth->bind_input_param("out1",\$out1,20);
$sth->bind_input_param("out2",\$out2,20);
$sth->bind_input_param("out3",\$out3,20);

To drop the stored procedure, run a query like the following.

drop procedure testproc
Sybase and Microsoft SQL Server

To create the stored procedure, run a query like the following.

create procedure testproc @in1 int, @in2 float, @in3 varchar(20), @out1 int output, @out2 int output, @out3 int output as
        select @out1=convert(varchar(20),@in1),
                @out2=convert(varchar(20),@in2),
                @out2=convert(varchar(20),@in2)

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dth->prepare("exec testproc");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,2,1);
$sth->bind_param("in3","hello");
my $out1;
my $out2;
my $out3;
$sth->bind_inout_param("out1",\$out1,20);
$sth->bind_inout_param("out2",\$out2,20);
$sth->bind_inout_param("out3",\$out3,20);
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
Interbase and Firebird

To create the stored procedure, run a query like the following.

create procedure testproc(in1 integer, in2 float, in3 varchar(20)) returns (out1 integer, out2 float, out3 varchar(20)) as
begin
        out1=in1;
        out2=in2;
        out3=in3;
        suspend;
end;

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dth->prepare("select * from testproc(?,?,?)");
$sth->bind_param("1",1);
$sth->bind_param("2",1.1,2,1);
$sth->bind_param("3","hello");
$sth->execute();
my $out1;
my $out2;
my $out3;
$sth->bind_columns(undef,\$out1,\$out1,\$out3);
$sth->fetch();

Alternatively, you can run a query like the following and receive the result using a output bind variables. Note that in Interbase/Firebird, input and output bind variable indices are distict from one another. The index of the first output bind variable is 1 rather than 4, even though there were 3 input bind variables.

my $sth=$dbh->prepare("execute procedure testproc ?, ?, ?");
$sth->bind_param("1",1);
$sth->bind_param("2",1.1,2,1);
$sth->bind_param("3","hello");
my $out1;
my $out2;
my $out3;
$sth->bind_inout_param("1",\$out1,20);
$sth->bind_inout_param("2",\$out2,20);
$sth->bind_inout_param("3",\$out3,20);
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
DB2

To create the stored procedure, run a query like the following.

create procedure testproc(in in1 int, in in2 double, in in3 varchar(20), out out1 int, out out2 double, out out3 varchar(20)) language sql
begin
        set out1 = in1;
        set out2 = in2;
        set out3 = in3;
end

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("call testproc(?,?,?,?,?,?)");
$sth->bind_param("1",1);
$sth->bind_param("2",1.1,2,1);
$sth->bind_param("3","hello");
my $out1;
my $out2;
my $out3;
$sth->bind_inout_param("4",\$out1,25);
$sth->bind_inout_param("5",\$out2,25);
$sth->bind_inout_param("6",\$out3,25);
$sth->execute();

To drop the stored procedure, run a query like the following.

drop procedure testproc
Postgresql

To create the stored procedure, run a query like the following.

create function testfunc(int,float,char(20)) returns record as '
declare
        output record;
begin
        select $1,$2,$3 into output;
        return output;
end;
' language plpgsql

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("select * from testfunc(:in1,:in2,:in3) as (col1 int, col2 float, col3 char(20))");
$sth->bind_param("in1",1);
$sth->bind_param("in2",1.1,4,2);
$sth->bind_param("in3","hello");
$sth->execute();
my $out1;
my $out2;
my $out3;
$sth->bind_columns(undef,\$out1,\$out2,\$out3);
$sth->fetch();

To drop the stored procedure, run a query like the following.

drop function testfunc(int,float,char(20))

Result Sets

Some stored procedures return entire result sets. Below are examples, illustrating how to create, execute and drop this kind of stored procedure for each database that SQL Relay supports.

Oracle

Stored procedures in Oracle can return open cursors as return values or output parameters. A client side cursor can be bound to this open cursor and rows can be fetched from it. However the SQL Relay driver for Perl DBI does not currently support output bind cursors.

Sybase and Microsoft SQL Server

Stored procedures in Sybase and Microsoft SQL Server can return a result set if the last command in the procedure is a select query, however SQL Relay doesn't currently support stored procedures that return result sets.

Interbase and Firebird

Stored procedures in Interbase and Firebird can return a result set if a select query in the procedure selects values into the output parameters and then issues a suspend command, however SQL Relay doesn't currently support stored procedures that return result sets.

DB2

Stored procedures in DB2 can return a result set if the procedure is declared to return one, however SQL Relay doesn't currently support stored procedures that return result sets.

Postgresql

To create the stored procedure, run a query like the following.

create function testfunc() returns setof record as '
        declare output record;
begin
        for output in select * from mytable loop
                return next output;
        end loop;
        return;
end;
' language plpgsql

To execute the stored procedure from an SQL Relay program, use code like the following.

my $sth=$dbh->prepare("select * from testfunc() as (testint int, testfloat float, testchar char(40))");
$sth->execute();
my $col1;
my $col2;
my $col3;
$sth->bind_columns(undef,\$col1,\$col2,\$col3);
while ($sth->fetch()) {
        print "$col, $col2, $col3, $col4\n";
}

To drop the stored procedure, run a query like the following.

drop function testfunc