Result:
found more than 464 distributions - search limited to the first 2001 files matching your query
( run in 0.872 )
DBD-D1
view release on metacpan or search on metacpan
lib/DBD/D1.pm view on Meta::CPAN
$sth->{NUM_OF_PARAMS} = $num_params;
$sth->{d1_params} = [];
$sth->{d1_rows_affected} = undef;
$sth->{d1_result_data} = undef;
$sth->{d1_cursor} = 0;
return $outer;
}
sub commit {
lib/DBD/D1.pm view on Meta::CPAN
$sth->{NAME_uc} = [];
$sth->{NUM_OF_FIELDS} = 0;
$sth->{d1_result_data} = [];
}
$sth->{d1_cursor} = 0;
$sth->{d1_rows_affected} = $meta->{changes} // $meta->{rows_affected} // 0;
$sth->{Active} = 1;
return $sth->{d1_rows_affected} || '0E0';
}
sub fetchrow_arrayref {
my ($sth) = @_;
my $data = $sth->{d1_result_data} or return undef;
my $cursor = $sth->{d1_cursor};
if ($cursor >= scalar @$data) {
$sth->{Active} = 0;
return undef;
}
$sth->{d1_cursor}++;
return $data->[$cursor];
}
*fetch = \&fetchrow_arrayref;
sub fetchall_arrayref {
lib/DBD/D1.pm view on Meta::CPAN
sub finish {
my ($sth) = @_;
$sth->{Active} = 0;
$sth->{d1_result_data} = undef;
$sth->{d1_cursor} = 0;
return 1;
}
sub FETCH {
my ($sth, $attr) = @_;
DBD-DB2
view release on metacpan or search on metacpan
tests/perld043_stmtTryFetchForNonSelect.pl view on Meta::CPAN
$sth->execute();
check_error("EXECUTE");
@row_ary = $sth->fetchrow();
check_error("FETCHROW",
"[IBM][CLI Driver] CLI0115E Invalid cursor state. SQLSTATE=24000",
"DBI::errstr");
check_value("FETCHROW", "row_ary", undef);
$sth->finish();
check_error("FINISH");
DBD-DBMaker
view release on metacpan or search on metacpan
Example:
print "First column may return NULL\n" if $sth->{NULLABLE}->[0];
=item CursorName (string) read-only
Returns the name of the cursor associated with the statement handle if
available.
=item Statement (string) read-only
Returns the statement string passed to the the prepare entry elsewhere in
DBD-DtfSQLmac
view release on metacpan or search on metacpan
DTF_TAT_AUTOCOMMIT
DTF_TAT_RESULTTYPE
These two attributes are very important, as they control the auto-commit behavior of the
database and the kind (sequential, random) of the result set's cursor. The following table
shows the available information regarding these attributes:
--------------------+------------+---------------+---------------+-------------------
Attribute | Attr. Type | current Value | default Value | Range
--------------------+------------+---------------+---------------+-------------------
=item B<$errcode = DtfResMoveToFirstRow ($hres);>
# move to the first row of a result table with a sequential cursor
# (the result table must be of type DTF_RT_SEQUENTIAL)
Arguments:
input: $hres a valid result handle
=item B<$errcode = DtfMoveToNextRow ($hres);>
# move to the next row of a result table with a sequential cursor
# (the result table must be of type DTF_RT_SEQUENTIAL)
Arguments:
input: $hres a valid result handle
=item B<$errcode = DtfResMoveToRow ($hres, $rowIndex);>
# moves a result set's cursor to an absolute position
# (the result table must be of type DTF_RT_RANDOM)
Arguments:
input: $hres a valid result handle
$rowIndex is the 0-based index of the row to move the cursor to
=item B<$errcode = DtfResQueryFieldInfo ($hres, $colIndex, $fieldSize, $isNull);>
DBD-Empress
view release on metacpan or search on metacpan
# --------------------------------------------------------------------------
# Cursor functions: prepare/execute/fetch/nrows, etc.
# --------------------------------------------------------------------------
print "Testing: \$cursor = \$dbh->prepare( 'SELECT FROM $test_tabname WHERE ¼±ÊÌ»Ò = 1' ): ";
( $cursor = $dbh->prepare( "SELECT * FROM $test_tabname WHERE ¼±ÊÌ»Ò = 1" ) )
and print( "prepare select ok\n" )
or print( "prepare select not ok: $DBI::errstr\n" );
print "Testing: \$cursor->execute: ";
( $cursor->execute )
and print( "execute select ok\n" )
or die "execute select not ok: $DBI::errstr\n";
# expect the following select to fail, as id=1 has been deleted already
print "Testing: \$cursor->fetchrow: ";
if ( @row = $cursor->fetchrow )
{
print( "not ok ($DBI::err): $DBI::errstr, record: @row\n" );
}
else
{
print( "ok\n" ); # expect it to fail for id=1
}
print "Testing: \$cursor->finish: ";
( $cursor->finish )
and print( "ok\n" )
or print( "not ok: $DBI::errstr\n" );
# multiple record tests
print "Testing: \$cursor = \$dbh->prepare( 'SELECT FROM $test_tabname' ): ";
( $cursor = $dbh->prepare( "SELECT * FROM $test_tabname" ) )
and print( "prepare select ok\n" )
or die "prepare select not ok: $DBI::errstr\n";
print "Testing: \$cursor->execute: ";
( $cursor->execute )
and print( "ok\n" )
or die "not ok: $DBI::errstr\n";
print "Testing: multiple \$cursor->fetchrow's:\n";
while ( @row = $cursor->fetchrow )
{
if ( $DBD::Empress::err != 0 )
{
print "Fetch Error ($DBD::Empress::err): $DBD::Empress::errstr\n";
}
print( "@row\n" )
}
print "Testing: \$cursor->finish: ";
( $cursor->finish )
and print( "ok\n" )
or die "not ok: $DBI::errstr\n";
( $dbh->disconnect )
and print(" d$iconnect\n")
DBD-EmpressNet
view release on metacpan or search on metacpan
# --------------------------------------------------------------------------
# Cursor functions: prepare/execute/fetch/nrows, etc.
# --------------------------------------------------------------------------
print "Testing: \$cursor = \$dbh->prepare( 'SELECT FROM $test_tabname WHERE ¼±ÊÌ»Ò = 1' ): ";
( $cursor = $dbh->prepare( "SELECT * FROM $test_tabname WHERE ¼±ÊÌ»Ò = 1" ) )
and print( "prepare select ok\n" )
or print( "prepare select not ok: $DBI::errstr\n" );
print "Testing: \$cursor->execute: ";
( $cursor->execute )
and print( "execute select ok\n" )
or die "execute select not ok: $DBI::errstr\n";
# expect the following select to fail, as id=1 has been deleted already
print "Testing: \$cursor->fetchrow: ";
if ( @row = $cursor->fetchrow )
{
print( "not ok ($DBI::err): $DBI::errstr, record: @row\n" );
}
else
{
print( "ok\n" ); # expect it to fail for id=1
}
print "Testing: \$cursor->finish: ";
( $cursor->finish )
and print( "ok\n" )
or print( "not ok: $DBI::errstr\n" );
# multiple record tests
print "Testing: \$cursor = \$dbh->prepare( 'SELECT FROM $test_tabname' ): ";
( $cursor = $dbh->prepare( "SELECT * FROM $test_tabname" ) )
and print( "prepare select ok\n" )
or die "prepare select not ok: $DBI::errstr\n";
print "Testing: \$cursor->execute: ";
( $cursor->execute )
and print( "ok\n" )
or die "not ok: $DBI::errstr\n";
print "Testing: multiple \$cursor->fetchrow's:\n";
while ( @row = $cursor->fetchrow )
{
if ( $DBD::EmpressNet::err != 0 )
{
print "Fetch Error ($DBD::EmpressNet::err): $DBD::EmpressNet::errstr\n";
}
print( "@row\n" )
}
print "Testing: \$cursor->finish: ";
( $cursor->finish )
and print( "ok\n" )
or die "not ok: $DBI::errstr\n";
( $dbh->disconnect )
and print(" d$iconnect\n")
DBD-Firebird
view release on metacpan or search on metacpan
Firebird.pm view on Meta::CPAN
Calling do() method without bind value(s) will do the same.
=item * CLOSE, OPEN, DECLARE CURSOR
$sth->{CursorName} is automagically available upon executing a "SELECT .. FOR
UPDATE" statement. A cursor is closed after the last fetch(), or by calling
$sth->finish().
=item * PREPARE, EXECUTE, FETCH
Similar functionalities are obtained by using prepare(), execute(), and
DBD-Fulcrum
view release on metacpan or search on metacpan
print "Doing a query (expecting 'Data truncated' error)... ";
#$::ful_dbh->{LongTruncOk} = 0;
#my $cursor = $::ful_dbh->prepare ('select ft_text,ft_sfname,filesize,title from test where title contains \'pippo\'', {fulcrum_MaximumHitsInInternalColumns => 100});
my $cursor = $::ful_dbh->prepare ('select ft_text,ft_sfname,filesize,title from test where title contains \'pippo\'');
if ($cursor) {
print "(execute) ... ";
$cursor->execute;
print "ok, now fetching (fetchrow): ";
my $text;
my @row;
my $eot;
my $data_truncated = 0;
while (@row = $cursor->fetchrow) {
$data_truncated++ if ($cursor->state =~ /01004/);
}
print "checking data truncated condition... ";
if ($data_truncated == 0) {
print "FAILED: did not detect 01004 [Data truncated] condition!\n";
exit 1;
exit 1;
}
print "Doing another query (this time you'll see the data)... ";
$DBD::Fulcrum::ful_maxhitsinternalcolumns = 64;
$cursor = $::ful_dbh->prepare ('select ft_text,ft_sfname,filesize,title from test where title contains \'pippo\'');
if ($cursor) {
print "(execute) ... ";
$cursor->execute;
print "ok, now fetching (fetchrow):\n***\n";
my $text;
my @row;
my $eot;
my $data_truncated = 0;
while (@row = $cursor->fetchrow) {
$data_truncated++ if ($DBI::state =~ /truncated/);
$cursor->blob_read (1, 0, 8192, \$text);
#or (print "+++ RB NOT OK:$DBI::errstr\n");
$text = $` if ($text =~ /\x00/);
print "(FILE: $row[1] TITLE: '$row[3]') "; #$text removed to clean up output
}
if ($data_truncated > 0) {
else {
print "FAILED: Prepare failed ($DBI::errstr)\n";
exit 1;
}
$cursor->finish;
$ful_dbh->disconnect;
print "Exiting\nIf you are here, then most likely all tests were successful.\n";
exit 0;
# end.
DBD-Illustra
view release on metacpan or search on metacpan
dbd-illustra.pod view on Meta::CPAN
Neither automatic row numbering nor row count limitations are supported.
=head3 Positioned updates and deletes
Illustra supports positioned updates or deletes in cursors that have been
explicitly created and opened C<FOR UPDATE>. For example:
$dbh->do("DECLARE cur1 CURSOR FOR SELECT * FROM tab1 FOR UPDATE");
$dbh->do("OPEN cur1");
$sth = $dbh->prepare("FETCH NEXT FROM cur1");
DBD-Informix
view release on metacpan or search on metacpan
Informix.pm view on Meta::CPAN
at the moment; yes, some clown in marketing decreased the version number).
All version families acquire extra versions on occasion.
Note that DBD::Informix does not work with Informix ESQL/C Version
4.1x or earlier versions because it uses both SQL descriptors and
strings for cursor names and statement names, and these features were
not available before Version 5.00.
For information about Informix software, you should also read the
Notes/FAQ file that is distributed with Informix Database Driver for Perl DBI.
Informix.pm view on Meta::CPAN
=head2 CREATING STATEMENTS
You can also prepare a statement for multiple uses, and you can do
this for SELECT and EXECUTE PROCEDURE statements that return data
(cursory statements) as well as noncursory statements that return no data.
You create a statement handle (another reference) using:
$sth = $dbh->prepare($stmt);
If the statement is a SELECT that returns data (not SELECT...INTO TEMP) or
an EXECUTE PROCEDURE for a procedure that returns values, a cursor is
declared for the prepared statement.
The prepare call accepts an optional attributes parameter that is a
reference to a hash.
Starting with version 1.03.PC1, the following attributes are recognized:
Informix.pm view on Meta::CPAN
The ix_ScrollCursor is a placeholder that may become unnecessary with a
future revision of DBI.
The ix_CursorWithHold attribute is only of relevance if AutoCommit is
disabled.
When AutoCommit is enabled, all cursors have to be WITH HOLD (just one
more reason to hate AutoCommit).
$sth = $dbh->prepare("SELECT id, name FROM tablename", {'ix_CursorWithHold' => 1});
After the cursor is opened ($sth->execute), it is not closed by
$dbh->commit().
Either fetch all the rows or use $sth->finish() to close it.
The ix_InsertCursor attribute can be applied to an INSERT statement (but
generates an error -481 for other types of statement).
Subsequent uses of $sth->execute() will use the ESQL/C PUT statement to
insert the data, and $sth->finish() will close the INSERT cursor.
There is at present no mechanism to invoke the FLUSH statement.
It would be reasonable to add {ix_BlobLocation => 'InFile'} to support
per-statement blob location.
Informix.pm view on Meta::CPAN
# Emphasizing the SQL action.
$sth = $dbh->prepare($stmt) or die "Failed to prepare '$stmt'\n"
You can tell whether the statement is just executable or whether it is
a cursory (fetchable) statement by testing the
Informix-specific attribute ix_Fetchable.
The approved, canonical DBI method of doing this check is
"$sth->{NUM_OF_FIELDS} > 0".
Once the statement is prepared, you can execute it:
$sth->execute;
For a noncursory statement, this simply executes the statement.
If the statement is executed successfully, the number of rows
affected will be returned.
If an error occurs, the returned value will be undef.
If the statement does not affect any rows, the string returned is
"0E0", which evaluates to true but also to zero.
For a cursory statement, $sth->execute opens the cursor.
If the cursor is opened successfully, it returns the value "0E0",
which evaluates to true but also to zero.
If an error occurs, the returned value will be undef.
You can also specify the input parameters for a statement that contains
question-marks as place-holders using:
Informix.pm view on Meta::CPAN
clause of the INSERT statement.
The INSERT statement is a special case, and it provides support for
code that implements the non-SQL statement 'LOAD FROM "file" INSERT
INTO SomeTable'.
For cursory statements, you can discover the returned column
names, types, nullability, and so on.
You do this with:
@name = @{$sth->{NAME}}; # Column names
@null = @{$sth->{NULLABLE}}; # True => accepts nulls
Informix.pm view on Meta::CPAN
For example, in "SELECT A.Column, B.Column FROM Table1 A, Table1 B
WHERE ...", both the return columns are described as 'column'.
=back
If the statement is a cursory statement, you can retrieve the
values in any of a number of ways, as described in the DBI
specification.
$ref = $sth->fetchrow_arrayref;
$ref = $sth->fetch; # Alternative spelling...
Informix.pm view on Meta::CPAN
BUG: ix_BlobLocation is not handled properly.
=back
When you have fetched as many rows as required, you close the cursor using:
$sth->finish;
You do not have to finish a cursor explicitly if you executed a fetch
that failed to retrieve any data.
Using $sth->finish simply closes the cursor but does not free the cursor
or the statement.
That is done when you destroy (undef) the statement handle:
undef $sth;
Informix.pm view on Meta::CPAN
$txt = $sth->{Statement};
=head2 CURSORS FOR UPDATE
You can use the (DBI standard) attribute $sth->{CursorName} to retrieve the name of a
cursor.
If the statement for $sth is actually a SELECT and the cursor is in a
MODE ANSI database or is declared with the 'FOR UPDATE [OF col,...'
tag, you can use the cursor name in a 'DELETE...WHERE CURRENT OF'
or 'UPDATE...WHERE CURRENT OF' statement.
$st1 = $dbh->prepare("SELECT * FROM SomeTable FOR UPDATE");
$wc = "WHERE CURRENT OF $st1->{CursorName}";
$st2 = $dbh->prepare("UPDATE SomeTable SET SomeColumn = ? $wc");
Informix.pm view on Meta::CPAN
In a MODE ANSI database, you can execute BEGIN WORK successfully.
However, if AutoCommit is On, the transaction is immediately
committed, so it does you no good.
If the user elects to switch to AutoCommit On, things get trickier.
All cursors need to be declared WITH HOLD so that Group 4B statements
being committed do not close the active cursors.
Whenever a Group 4B statement is executed, the statement needs to be
committed.
With OnLine (and theoretically with SE), if the statement fails there
is no need to do a rollback -- the statement failing did the rollback
anyway.
Informix.pm view on Meta::CPAN
$sth->execute => EXECUTE or OPEN
$sth->fetch => FETCH
$sth->fetchrow => FETCH
$sth->finish => CLOSE
undef $sth => FREE cursor, FREE statement, etc
=head1 KNOWN RESTRICTIONS
=over 2
DBD-Informix4
view release on metacpan or search on metacpan
Informix4.xs view on Meta::CPAN
CODE:
D_imp_dbh(dbh);
if ( !DBIc_ACTIVE(imp_dbh) ) {
XSRETURN_YES;
}
/* Check for disconnect() being called whilst refs to cursors */
/* still exists. This possibly needs some more thought. */
if (DBIc_ACTIVE_KIDS(imp_dbh) && DBIc_WARN(imp_dbh) && !dirty) {
warn("disconnect(%s) invalidates %d active cursor(s)",
SvPV(dbh,na), (int)DBIc_ACTIVE_KIDS(imp_dbh));
}
ST(0) = dbd_db_disconnect(dbh, imp_dbh) ? &sv_yes : &sv_no;
DBD-Ingres
view release on metacpan or search on metacpan
if ($sql_sth) {
$sql_sth->finish;
undef $sql_sth;
1;
} else {
carp "Ingperl: close with no open cursor, at"
if $sql_drh->{Warn};
1;
}
}
sub sql_fetch {
croak "Ingperl: No active cursor, at" unless $sql_sth;
my(@row) = $sql_sth->fetchrow();
$sql_rowcount = $sql_sth->rows();
unless (@row) {
&sql_close();
return wantarray ? () : undef;
sub sql_eval_row1{
my $sth = $sql_dbh->prepare(@_);
return undef unless $sth;
$sth->execute or return undef;
my(@row) = $sth->fetchrow; # fetch one row
$sth->finish; # close the cursor
undef $sth;
@row;
}
# Library function to execute a select and return first col
$sth->execute or return undef;
my ($row, @col);
while ($row = $sth->fetch){
push(@col, $row->[0]);
}
$sth->finish; # close the cursor
undef $sth;
@col;
}
package Ingperl::var;
@values = &sql_fetch;
Fetch the next record of data returned from the last prepared
select statement. When all records have been returned &sql_fetch
will close the select statement cursor and return an empty array.
For example:
&sql('select * from iitables') || die $sql_error;
while(@values = &sql_fetch){
B<DBD:> C<&sql_fetch> will call C<&sql_close> when the last row of data
has been fetched. This has been the way it was supposed to be...
B<DBD:> C<&sql_fetch> will die with the error C<Ingperl: No active
cursor> if an error has occured in the C<&sql(select..)>-statement.
B<DBD:> C<$scalar = &sql_fetch> returns the first column of data if
C<$sql_sth-E<gt>{CompatMode}> is set; this is the default mode for
Ingperl and is the expected behaviour for Perl4. In Perl5 (and with
C<$sql_sth-E<gt>{CompatMode}> unset) the number of columns will be
=item * sql_close
&sql_close;
This function needs to be called B<only> if you do not use C<&sql_fetch>
to fetch B<all> the records B<and> you wish to close the cursor as soon as
possible (to release locks etc). Otherwise ignore it. Always returns
true.
B<DBD:> If C<$sql_sth-E<gt>{Warn}> is false the warning C<Ingperl: close
with no open cursor> will be given whenever a closed cursor is reclosed.
The default behaviour is to omit the warning.
=back
IngPerl Functions to describe the currently prepared statement. These
Create Table As Select or Copy this variable holds the number of rows
affected.
=item * $sql_readonly (default 1)
If true then prepared sql statements are given read only cursors this is
generally a considerable performance gain.
B<DBD:> Not implemented. All cursors are readonly - there is no way to
modify the value of a cursor element, therefore no reason not to make
the cursors readonly. The value of this variable was ignored already in
Ingperl 2.0.
=item * $sql_showerrors (default 0)
If true then ingres error and warning messages are printed by
@row1 = &sql_eval_row1('select ...');
Execute a select statement and return the first row.
B<DBD:> This is executed in a separate cursor and can therefore be
executed while a &sql_fetch-loop is in progres.
=item * sql_eval_col1
@col1 = &sql_eval_col1('select ...');
Execute a select statement and return the first column.
B<DBD:> As &sql_eval_col1 this is executed in a separate cursor.
=head1 NOTES
The DBD::Ingres module has been modelled closely on Tim Bunce's
DBD::Oracle module and warnings that apply to DBD::Oracle and the
DBD-IngresII
view release on metacpan or search on metacpan
IngresII.pm view on Meta::CPAN
execute time rather than bind time. (Similar to bind_param_inout, except
you don't pass them as references.)
=head2 ing_readonly
Normally cursors are declared C<READONLY> to increase speed. READONLY
cursors don't create exclusive locks for all the rows selected; this is
the default.
If you need to update a row then you will need to ensure that either
=over 4
IngresII.pm view on Meta::CPAN
{ ing_readonly => 1} );
will be opened C<FOR READONLY>.
When you wish to actually do the update, where you would normally put the
cursor name, you put:
$sth->{CursorName}
instead, for example:
IngresII.pm view on Meta::CPAN
$sth->execute;
and so on. B<Note> that an C<update> will now cause an SQL error.
In fact the "FOR UPDATE" seems to be optional, i.e., you can update
cursors even if their SELECT statements do not contain a C<for update>
part.
If you wish to update such a cursor you B<must> include the C<ing_readonly>
attribute.
B<NOTE> DBD::IngresII version later than 0.19_1 have opened all cursors for
update. This change breaks that behaviour. Sorry if this breaks your code.
=head2 ing_rollback
The DBI docs state that 'Changing C<AutoCommit> from off to on will
IngresII.pm view on Meta::CPAN
=head2 disconnect_all
Not implemented
=head2 commit and rollback invalidate open cursors
DBD::IngresII should warn when a commit or rollback is isssued on a $dbh
with open cursors.
Possibly a commit/rollback should also undef the $sth's. (This should
probably be done in the DBI-layer as other drivers will have the same
problems).
After a commit or rollback the cursors are all ->finish'ed, i.e., they
are closed and the DBI/DBD will warn if an attempt is made to fetch
from them.
A future version of DBD::IngresII wil possibly re-prepare the statement.
DBD-InterBase
view release on metacpan or search on metacpan
InterBase.pm view on Meta::CPAN
Calling do() method without bind value(s) will do the same.
=item * CLOSE, OPEN, DECLARE CURSOR
$sth->{CursorName} is automagically available upon executing a "SELECT .. FOR
UPDATE" statement. A cursor is closed after the last fetch(), or by calling
$sth->finish().
=item * PREPARE, EXECUTE, FETCH
Similar functionalities are obtained by using prepare(), execute(), and
InterBase.pm view on Meta::CPAN
}
=item * Using $dbh->{ib_softcommit} = 1
This driver-specific attribute is available as of version 0.30. You may want
to look at t/40cursoron.t to see it in action.
=back
=head2 Why do nested statement handles break under AutoCommit mode?
( run in 0.872 second using v1.01-cache-2.11-cpan-cdf2f3d4e48 )