NAME
    DBIx::SQLEngine::Docs::ReadMe - Welcome to DBIx::SQLEngine

ABSTRACT
    The DBIx::SQLEngine class provides an extended interface for the DBI
    database framework. Each SQLEngine object is a wrapper around a DBI
    database handle, adding methods that support ad-hoc SQL generation and
    query execution in a single call. Dynamic subclassing based on database
    server type enables cross-platform portability.

DESCRIPTION
    DBIx::SQLEngine is the latest generation of a toolkit used by the
    authors for several years to develop business data applications and
    object-relational mapping toolkits. Its goal is to simplify dynamic
    query execution with the following capabilities:

    *   Data-driven SQL: Ad-hoc generation of SQL statements from Perl data
        structures in a variety of formats; simple hash and array references
        are flexibly converted to form clauses in standard SQL query syntax.

    *   High-Level Interface: Standard query operations are handled by a
        single method call each. Error handling is standardized, and routine
        annoyances like timed-out connections are retried automatically.

    *   Full DBI Access: Accepts arbitrary SQL queries with placeholder
        parameters to be passed through, and delegates all other method
        calls to a wrapped database handle, allowing access to the entire
        DBI API for cases when high-level interfaces are insufficient

    *   Portability Subclasses: Uses dynamic subclassing (via DBIx::AnyDBD)
        to allow platform-specific support for driver idiosyncrasies and
        DBMS workarounds. This release includes subclasses for connections
        to MySQL, PostgreSQL, Oracle, and Microsoft SQL servers, as well as
        for the standalone SQLite, AnyData, and CSV packages.

  Data-driven SQL

    Several methods are responsible for converting their arguments into
    commands and placeholder parameters in SQL, the Structured Query
    Language.

    The various methods whose names being with sql_, like sql_select and
    sql_insert, each accept a hash of arguments and combines then to return
    a SQL statement and corresponding parameters. Data for each clause of
    the statement is accepted in multiple formats to facilitate query
    abstraction, often including various strings, array refs, and hash refs.
    Each method also supports passing arbitrary queries through using a
    "sql" parameter.

  High-Level Interface

    The combined query interface provides a useful high-level idiom to
    perform the typical cycle of SQL generation, query execution, and
    results fetching, all through a single method call.

    The various fetch_*, visit_* and do_* methods that don't end in _sql,
    like fetch_select and do_insert, are wrappers that combine a
    SQL-generation and a SQL-execution method to provide a simple ways to
    perform a query in one call.

  Full DBI Access

    Each DBIx::SQLEngine object is implemented as a wrapper around a
    database handle provided by DBI, the Perl Database Interface.

    Arbitrary queries can be executed, bypassing the SQL generation
    capabilities. The methods whose names end in _sql, like fetch_sql and
    do_sql, each accept a SQL statement and parameters, pass it to the DBI
    data source, and return information about the results of the query.

  Portability Subclasses

    Behind the scenes, different subclasses of SQLEngine are instantiated
    depending on the type of server to which you connect, thanks to
    DBIx::AnyData. As a result, some range of SQL dialect ideosyncracies can
    be compensated for.

    For example, the sql_limit method controls the syntax for select
    statements with limit and offset clauses, and both MySQL and Oracle
    override this method to use their local syntax.

    The only method that's actually provided by the DBIx::SQLEngine class
    itself is the new() constructor. All of the other methods are defined in
    DBIx::SQLEngine::Driver::Default, or in one of its automatically-loaded
    subclasses.

    The public interface of DBIx::SQLEngine is shared by all of its
    subclasses. The superclass methods aim to produce and perform generic
    queries in an database-independent fashion, using standard SQL syntax.
    Subclasses may override these methods to compensate for idiosyncrasies
    of their database server or mechanism. To facilitate cross-platform
    subclassing, many of these methods are implemented by calling
    combinations of other methods, which may individually be overridden by
    subclasses.

DISTRIBUTION AND INSTALLATION
  Version

    This version is a routine release of DBIx::SQLEngine intended for public
    use.

    This module's proposed CPAN registration should read:

      Name            DSLIP  Description
      --------------  -----  ---------------------------------------------
      DBIx::
      ::SQLEngine     Rdpop  Extends DBI with high-level operations

  Prerequisites

    This package requires these other modules and libraries:

      DBI                           1.0
      DBIx::AnyDBD                  2.0
      Class::MakeMethods            1.003

    You must also have at least one working DBD module installed.

    If you run into trouble, check that your DBI and DBD modules are
    up-to-date; in particular, if you are using DBD::CSV or DBD::AnyData,
    make sure you have upgraded to SQL::Statement 1.0 or later.

  Installation

    You should be able to install this module using the CPAN shell
    interface:

      perl -MCPAN -e 'install DBIx::SQLEngine'

    In order for the test to succeed, you must also have at least one
    working DBD module installed, and must provide a DSN to which the script
    can connect with permissions to create tables.

    Alternately, you may retrieve this package from CPAN or from the
    author's site:

    * http://search.cpan.org/~evo/

    * http://www.cpan.org/modules/by-authors/id/E/EV/EVO

    * http://www.evoscript.org/DBIx-SQLEngine/

    After downloading the distribution, follow the normal procedure to
    unpack and install it, using the commands shown below or their local
    equivalents on your system:

      tar xzf DBIx-SQLEngine-*.tar.gz
      cd DBIx-SQLEngine-*
      perl Makefile.PL
      make test && sudo make install

    Furthermore, thanks to the kind generosity of other members of the Perl
    community, this distribution is also available repackaged in the FreeBSD
    "ports" and Linux RPM formats. This may simplify installation for some
    users, but be aware that these alternate distributions may lag a few
    versions behind the latest release on CPAN.

    * http://www.freebsd.org/cgi/ports.cgi?query=DBIx-SQLEngine

    * http://www.rpmfind.net/linux/rpm2html/search.php?query=perl-DBIx-SQLEn
      gine

  Tested Platforms

    This release has been tested succesfully on the following platforms:

      5.6.1 on darwin

    You may also review the current test results from CPAN-Testers:

    * http://testers.cpan.org/show/DBIx-SQLEngine.html

BUGS AND SUPPORT
  Known Problems

    Many types of database servers are not yet supported.

    Database driver/server combinations that do not support placeholders
    will fail.
    (http://groups.google.com/groups?selm=dftza.3519%24ol.117790%40news.chel
    lo.at)

    See the DBIx::SQLEngine::ToDo manpage for additional bugs and missing
    features.

  Release Status

    This module has been used in a variety of production systems and has
    been available on CPAN for over a year, with several other distributions
    dependant on it, so it would be fair to say that it is fully released.

    However, while the commonly-used portions are well tested, some of the
    more obscure combinations of options are less so, and new bug reports do
    trickle in occasionally. If you do encounter any problems, please inform
    the author and I'll endeavor to patch them promptly.

    Additional features have been outlined for future development, but the
    intent is support these by adding more options to the declaration
    interface, while maintaining backward compatibility.

  Support

    If you have questions or feedback about this module, please feel free to
    contact the author at the below address. Although there is no formal
    support program, I do attempt to answer email promptly.

    I would be particularly interested in any suggestions towards improving
    the documentation, correcting any Perl-version or platform dependencies,
    as well as general feedback and suggested additions.

    Bug reports that contain a failing test case are greatly appreciated,
    and suggested patches will be promptly considered for inclusion in
    future releases.

    To report bugs via the CPAN web tracking system, go to
    "http://rt.cpan.org/NoAuth/Bugs.html?Dist=DBIx-SQLEngine" or send mail
    to "Dist=DBIx-SQLEngine#rt.cpan.org", replacing the "#" with "@".

  Community

    If you've found this module useful or have feedback about your
    experience with it, consider sharing your opinion with other Perl users
    by posting your comment to CPAN's ratings system:

    * http://cpanratings.perl.org/rate/?distribution=DBIx-SQLEngine

    For more general discussion, you may wish to post a message on PerlMonks
    or the comp.lang.perl.misc newsgroup:

    * http://www.perlmonks.org/index.pl?node=Seekers%20of%20Perl%20Wisdom

    * http://groups.google.com/groups?group=comp.lang.perl.misc

    There have been a few small discussions of this module on PerlMonks and
    Usenet in the past:

    * http://groups.google.com/groups?q=dbix+sqlengine+-ports&scoring=d

    * http://perlmonks.org/index.pl?node_id=3989&BIT=sqlengine&go=Search

SEE ALSO
    See the DBIx::SQLEngine manpage for interface documentation.

    See the DBIx::SQLEngine::Docs::Changes manpage for revision history.

    See the DBIx::SQLEngine::Docs::Related manpage for notes on related
    modules.

CREDITS AND COPYRIGHT
  Author

    Developed by Matthew Simon Cavalletto at Evolution Softworks.

    You may contact the author directly at "evo@cpan.org" or
    "simonm@cavalletto.org". More free Perl software is available at
    "www.evoscript.org".

  Contributors

    Many thanks to the kind people who have contributed code and other
    feedback:

      Eric Schneider, Evolution Online Systems
      E. J. Evans, Evolution Online Systems
      Matthew Sheahan, Evolution Online Systems
      Eduardo Iturrate, Evolution Online Systems
      Ron Savage
      Christian Glahn, Innsbruck University
      Michael Kroll, Innsbruck University

  Copyright

    Copyright 2001, 2002, 2003, 2004 Matthew Cavalletto.

    Portions copyright 1998, 1999, 2000, 2001 Evolution Online Systems, Inc.

    Portions copyright 2002 ZID, Innsbruck University (Austria).

    Portions of the documentation are copyright 2003 Ron Savage.

  License

    You may use, modify, and distribute this software under the same terms
    as Perl.

