DBIx::Simple man page on Mandriva

Man page or keyword search:  
man Server   17060 pages
apropos Keyword Search (all sections)
Output format
Mandriva logo
[printable version]

DBIx::Simple(3)	      User Contributed Perl Documentation      DBIx::Simple(3)

NAME
       DBIx::Simple - Easy-to-use OO interface to DBI

SYNOPSIS
       DBIx::Simple

	   $db = DBIx::Simple->connect(...)  # or ->new

	   $db->keep_statements = 16
	   $db->lc_columns = 1
	   $db->result_class = 'DBIx::Simple::Result';

	   $db->begin_work	   $db->commit
	   $db->rollback	   $db->disconnect
	   $db->func(...)	   $db->last_insert_id

	   $result = $db->query(...)

       DBIx::SImple + SQL::Interp

	   $result = $db->iquery(...)

       DBIx::Simple + SQL::Abstract

	   $db->abstract = SQL::Abstract->new(...)

	   $result = $db->select(...)
	   $result = $db->insert(...)
	   $result = $db->update(...)
	   $result = $db->delete(...)

       DBIx::Simple::Result

	   @columns = $result->columns

	   $result->into($foo, $bar, $baz)
	   $row = $result->fetch

	   @row = $result->list	   @rows = $result->flat
	   $row = $result->array   @rows = $result->arrays
	   $row = $result->hash	   @rows = $result->hashes

	   %map = $result->map_arrays(...)
	   %map = $result->map_hashes(...)
	   %map = $result->map

	   $rows = $result->rows

	   $dump = $result->text

	   $result->finish

       DBIx::Simple::Result + DBIx::XHTML_Table

	   $html = $result->html(...)

	   $table_object = $result->xto(...)

       Examples

       Please read DBIx::Simple::Examples for code examples.

DESCRIPTION
       DBIx::Simple provides a simplified interface to DBI, Perl's powerful
       database module.

       This module is aimed at rapid development and easy maintenance. Query
       preparation and execution are combined in a single method, the result
       object (which is a wrapper around the statement handle) provides easy
       row-by-row and slurping methods.

       The "query" method returns either a result object, or a dummy object.
       The dummy object returns undef (or an empty list) for all methods and
       when used in boolean context, is false. The dummy object lets you
       postpone (or skip) error checking, but it also makes immediate error
       checking simply "$db->query(...) or die $db->error".

       DBIx::Simple methods

       "DBIx::Simple->connect($dbh)"
       "DBIx::Simple->connect($dsn, $user, $pass, \%options)"
       "DBIx::Simple->new($dbh)"
       "DBIx::Simple->new($dsn, $user, $pass, \%options)"
	   The "connect" or "new" class method takes either an existing DBI
	   object ($dbh), or a list of arguments to pass to "DBI->connect".
	   See DBI for a detailed description.

	   You cannot use this method to clone a DBIx::Simple object: the $dbh
	   passed should be a DBI::db object, not a DBIx::Simple object.

	   This method is the constructor and returns a DBIx::Simple object on
	   success. On failure, it returns undef.

       "lc_columns = $bool"
	   When true at time of query execution, makes "columns", "hash",
	   "hashes", and "map_hashes" use lower cased column names.
	   "lc_columns" is true by default.

       "keep_statements = $integer"
	   Sets the number of statement objects that DBIx::Simple can keep for
	   reuse. This can dramatically speed up repeated queries (like when
	   used in a loop).  "keep_statements" is 16 by default.

	   A query is only reused if it equals a previously used one
	   literally. This means that to benefit from this caching mechanism,
	   you must use placeholders and never interpolate variables yourself.

	       # Wrong:
	       $db->query("INSERT INTO foo VALUES ('$foo', '$bar', '$baz')");
	       $db->query("SELECT FROM foo WHERE foo = '$foo' OR bar = '$bar'");

	       # Right:
	       $db->query('INSERT INTO foo VALUES (??)', $foo, $bar, $baz);
	       $db->query('SELECT FROM foo WHERE foo = ? OR bar = ?', $foo, $baz);

	   Of course, automatic value escaping is a much better reason for
	   using placeholders.

       "result_class = $string"
	   Class to use for result objects. Defaults to DBIx::Simple::Result.
	   A constructor is not used.

       "error"
	   Returns the error string of the last DBI method. See the discussion
	   of ""err"" and ""errstr"" in DBI.

       "query($query, @values)"
	   The "query" method prepares and executes the query and returns a
	   result object.

	   If the string "(??)" is present in the query, it is replaced with a
	   list of as many question marks as @values.

	   The database drivers substitute placeholders (question marks that
	   do not appear in quoted literals) in the query with the given
	   @values, after them escaping them. You should always use
	   placeholders, and never use raw user input in database queries.

	   On success, returns a DBIx::Simple::Result object.

	   On failure, returns a DBIx::Simple::Dummy object.

       "iquery"
	   Uses SQL::Interp to interpolate values into a query, and uses the
	   resulting generated query and bind arguments with "query".

	   See SQL::Interp's documentation for usage information.

	   Requires that Mark Stosberg's SQL::Interp module be installed. It
	   is available from CPAN. SQL::Interp is a fork from David Manura's
	   SQL::Interpolate.

       "select", "insert", "update", "delete"
	   Calls the respective method on "abstract", and uses the resulting
	   generated query and bind arguments with "query".

	   See SQL::Abstract's documentation for usage information. You can
	   override the object by assigning to the "abstract" property.

	   Obviously, calling "query" directly is faster for the computer and
	   using these abstracting methods is faster for the programmer.

       "abstract = SQL::Abstract->new(...)"
	   Sets the object to use with the "select", "insert", "update" and
	   "delete" methods. On first access, will create one with
	   SQL::Abstract's default options.

	   Requires that Nathan Wiger's SQL::Abstract module be installed. It
	   is available from CPAN.

	   In theory, you can assign any object to this property, as long as
	   that object has these four methods, and they return a list suitable
	   for use with the "query" method.

       "begin_work", "begin", "commit", "rollback"
	   These transaction related methods call the DBI respective methods
	   and Do What You Mean. See DBI for details.

	   "begin" is an alias for "begin_work".

       "func(...)"
	   This calls the "func" method of DBI. See DBI for details.

       "last_insert_id(...)"
	   This calls the "last_insert_id" method of DBI. See DBI for details.
	   Note that this feature requires DBI 1.38 or newer.

       "dbh"
	   Exposes the internal database handle. Use this only if you know
	   what you are doing. Keeping a reference or doing queries can
	   interfere with DBIx::Simple's garbage collection and error
	   reporting.

       "disconnect"
	   Destroys (finishes) active statements and disconnects. Whenever the
	   database object is destroyed, this happens automatically if
	   DBIx::Simple handled the connection (i.e. you didn't use an
	   existing DBI handle). After disconnecting, you can no longer use
	   the database object or any of its result objects.

       DBIx::Simple::Dummy

       The "query" method of DBIx::Simple returns a dummy object on failure.
       Its methods all return an empty list or undef, depending on context.
       When used in boolean context, a dummy object evaluates to false.

       DBIx::Simple::Result methods

       "columns"   Returns a list of column names. In scalar context, returns
		   an array reference.

		   Column names are lower cased if "lc_columns" was true when
		   the query was executed.

       "bind(LIST)"
		   Binds the given LIST to the columns. The elements of LIST
		   must be writable LVALUEs. In other words, use this method
		   as:

		       $result->bind(my ($foo, $bar));
		       $result->fetch;

		   Or, combined:

		       $result->into(my ($foo, $bar));

		   Unlike with DBI's "bind_columns", the "\" operator is not
		   needed.

		   Bound variables are very efficient. Binding a tied variable
		   doesn't work.

       "fetch"	   Fetches a single row and returns a reference to the array
		   that holds the values. This is the same array every time.

		   Subsequent fetches (using any method) may change the values
		   in the variables passed and the returned reference's array.

       "into(LIST)"
		   Combines "bind" with "fetch". Returns what "fetch" returns.

       "list"	   Fetches a single row and returns a list of values. In
		   scalar context, returns only the last value.

       "array"	   Fetches a single row and returns an array reference.

       "hash"	   Fetches a single row and returns a hash reference.

		   Keys are lower cased if "lc_columns" was true when the
		   query was executed.

       "flat"	   Fetches all remaining rows and returns a flattened list.

		   In scalar context, returns an array reference.

       "arrays"	   Fetches all remaining rows and returns a list of array
		   references.

		   In scalar context, returns an array reference.

       "hashes"	   Fetches all remaining rows and returns a list of hash
		   references.

		   In scalar context, returns an array reference.

		   Keys are lower cased if "lc_columns" was true when the
		   query was executed.

       "map_arrays($column_number)"
		   Constructs a hash of array references keyed by the values
		   in the chosen column.

		   In scalar context, returns a hash reference.

		   In list context, returns interleaved keys and values.

       "map_hashes($column_name)"
		   Constructs a hash of hash references keyed by the values in
		   the chosen column.

		   In scalar context, returns a hash reference.

		   In list context, returns interleaved keys and values.

       "map"	   Constructs a simple hash, using the two columns as
		   key/value pairs. Should only be used with queries that
		   return two columns.

		   In scalar context, returns a hash reference.

		   In list context, returns interleaved keys and values.

       "rows"	   Returns the number of rows affected by the last row
		   affecting command, or -1 if the number of rows is not known
		   or not available.

		   For SELECT statements, it is generally not possible to know
		   how many rows are returned. MySQL does provide this
		   information. See DBI for a detailed explanation.

       "xto(%attr)"
		   Returns a DBIx::XHTML_Table object, passing the constructor
		   a reference to %attr.

		   Requires that Jeffrey Hayes Anderson's DBIx::XHTML_Table
		   module be installed.	 It is available from CPAN.

		   In general, using the "html" method (described below) is
		   much easier. "xto" is available in case you need more
		   flexibility.

		   This method ignores the "lc_columns" property.

       "html(%attr)"
		   Returns an (X)HTML formatted table, using the
		   DBIx::XHTML_Table module. Passes a reference to %attr to
		   both the constructor and the "output" method.

		   Requires that Jeffrey Hayes Anderson's DBIx::XHTML_Table
		   module be installed.	 It is available from CPAN.

		   This method is a shortcut method. That means that

		       $result->html

		       $result->html(
			   tr => { bgcolor => [ 'silver', 'white' ] },
			   no_ucfirst => 1
		       )

		   do the same as:

		       $result->xto->output

		       $result->xto(
			   tr => { bgcolor => [ 'silver', 'white' ] }
		       )->output(
			   no_ucfirst => 1
		       );

       "text($type)"
		   Returns a string with a simple text representation of the
		   data. $type can be any of: "neat", "table", "box". It
		   defaults to "table" if Text::Table is installed, to "neat"
		   if it is.

		   "table" and "box" require that Anno Siegel's Text::Table
		   module be installed. It is available from CPAN.

       "attr(...)" Returns a copy of an sth attribute (property). See
		   "Statement Handle Attributes" in DBI for details.

       "func(...)" This calls the "func" method of DBI. See DBI for details.

       "finish"	   Finishes the statement. After finishing a statement, it can
		   no longer be used.  When the result object is destroyed,
		   its statement handle is automatically finished and
		   destroyed. There should be no reason to call this method
		   explicitly; just let the result object go out of scope.

MISCELLANEOUS
       The mapping methods do not check whether the keys are unique. Rows that
       are fetched later overwrite earlier ones.

       PrintError is disabled by default. If you enable it, beware that it
       will report line numbers in DBIx/Simple.pm.

LICENSE
       There is no license. This software was released into the public domain.
       Do with it what you want, but on your own risk. The author disclaims
       any responsibility.

AUTHOR
       Juerd Waalboer <juerd@cpan.org> <http://juerd.nl/>

SEE ALSO
       perl, perlref

       DBI, DBIx::Simple::Examples, SQL::Abstract, DBIx::XHTML_Table

perl v5.10.0			  2007-09-17		       DBIx::Simple(3)
[top]

List of man pages available for Mandriva

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net