ADDED   Bakefiles.bkgen
Index: Bakefiles.bkgen
==================================================================
--- /dev/null
+++ Bakefiles.bkgen
@@ -0,0 +1,21 @@
+<?xml version="1.0" ?>
+<bakefile-gen xmlns="http://www.bakefile.org/schema/bakefile-gen">
+    <input>
+        ./mysql++.bkl
+    </input>
+
+    <!-- List of output formats to generate: -->
+    <add-formats>
+        autoconf,mingw,msvs2003prj,msvs2005prj,xcode2
+    </add-formats>
+
+    <add-flags formats="mingw">
+        -o$(INPUT_FILE_DIR)/Makefile.mingw
+    </add-flags>
+	<add-flags formats="msvs2003prj">
+		-ovc2003/mysql++.sln
+	</add-flags>
+	<add-flags formats="msvs2005prj">
+		-ovc2005/mysql++.sln
+	</add-flags>
+</bakefile-gen>

ADDED   COPYING.txt
Index: COPYING.txt
==================================================================
--- /dev/null
+++ COPYING.txt
@@ -0,0 +1,10 @@
+The MySQL++ library proper and the reference manual derived from
+comments in the library source code are licensed under the GNU Lesser
+General Public License. A copy is provided in this directory, in the
+file LICENSE.txt.
+
+The MySQL++ User Manual is licensed under a unique license derived from
+the Linux Documentation Project License. (The only changes are due to
+the fact that the User Manual isn't actually part of the LDP, so a lot
+of the language in the LDPL doesn't make sense when applied to the user
+manual.)  This license is provided in the file doc/userman/LICENSE.txt.

DELETED COPYRIGHT
Index: COPYRIGHT
==================================================================
--- COPYRIGHT
+++ /dev/null
@@ -1,23 +0,0 @@
-The Mysql++ API is copyright 1998 by Kevin Atkinson and is released
-under the LGPL license for now.
-
-The intent of doing this is allow developers to use my library to
-develop commercial programs and to allow it it be distributed with
-commercial databases.
-
-However if you do use it to develop a commercial program a small
-donation to me would be greatly appreshated.  Your donation will will
-encourage me to continue to work on improving this API and also
-encourage me to contune to keep it under the LGPL.  Please send
-donations too.
-  Kevin Atkinson
-  7962 Helmart Dr.
-  Laurel, MD 20723
-
-I reserve the right to change the license to future versions of the
-library if I do not get suffecent pay-back to my work.  However, it is
-my promise to you that it will never become more restrictive than the
-GPL (not LGPL) licence.
-
-You can contact me at kevinatk@home.com or (301) 498-3290 or at 
-7962 Helmart Dr./Laurel, MD 20723.

ADDED   CREDITS.txt
Index: CREDITS.txt
==================================================================
--- /dev/null
+++ CREDITS.txt
@@ -0,0 +1,93 @@
+MySQL++ was created by Kevin Atkinson during 1998. From version 1.0
+(released in June 1999) through 1.7.9 (May 2001), the primary maintainer
+was Sinisa Milivojevic <sinisa@mysql.com>. Neither Kevin nor Sinisa
+are currently involved in MySQL++ development. The current maintainer
+is Warren Young <mysqlpp@etr-usa.com>, starting with version 1.7.10 in
+August of 2004.
+
+For a fuller account of the library's history, see the first chapter
+of the user manual.  For the nitty-gritty details, see the ChangeLog
+in the root package directory.  ChangeLog items since 1.7.9 that
+aren't attributed to anyone else were done by Warren Young.
+
+
+Other contributors of note since 1.7.10:
+
+    Chris Frey <cdfrey@netdirect.ca>: Lots of GCC warning fixes for the
+    bleeding-edge compiler versions, and Gentoo ebuild support.
+
+    Mark Meredino <Mark_Merendino@cnt.com>: Several fixes and
+    additions, including a lot of work on Microsoft Visual C++
+    compatibility, and discoveries made while spelunking in the
+    library.
+
+    Evan Wies <evan@athenacr.com>: Contributed several C++ code
+    style cleanups.
+
+    Arnon Jalon <Arnon.Jalon@247RealMedia.com>: Added the multi-query
+    result set handling features, and examples/multiquery.cpp to
+    demonstrate it.
+
+    Korolyov Ilya has submitted several patches in many different
+    areas of the library.
+
+    Remi Collet <Liste@FamilleCollet.com> is maintaining offical RPMs
+    for Fedora, with other systems on the way.  His work has improved
+    the RPM spec file we distribute greatly.
+
+    Joel Fielder <joel.fielder@switchplane.com> came up with the
+    original idea for Query::for_each() and Query::store_in(),
+    provided the basis for examples/for_each.cpp, and provided a fix
+    for exception flag propagation in Query.
+
+    Jim Wallace <jwallace@kaneva.com> demonstrated the need
+    for BadQuery::errnum(), and contributed the patches and also
+    examples/deadlock.cpp to test that this feature does what it is
+    supposed to.
+
+    Jonathan Wakely <mysql@kayari.org> rebuilt my original versions
+	of ConnectionPool, RefCountedPointer, and RefCountedBuffer.
+	They're now simpler and safer.  He also created the numeric
+    conversion logic in lib/mystring.h introduced in v3.0.
+
+
+Here are the personal credits from the old 1.7.9 documentation,
+apparently written by Kevin Atkinson:
+
+    Chris Halverson - For helping me get it to compile under Solaris.
+
+    Fredric Fredricson - For a long talk about automatic conversions.
+
+    Michael Widenius - MySQL developer who has been very supportive of
+        my efforts.
+
+    Paul J. Lucas - For the original idea of treating the query object
+        like a stream.
+
+    Scott Barron - For helping me with the shared libraries.
+
+    Jools Enticknap - For giving me the Template Queries idea.
+
+    M. S. Sriram - For a detailed dission of how the Template Queries
+        should be implemented, the suggestion to throw exceptions on bad
+        queries, and the idea of having a back-end independent query
+        object (ie SQLQuery).
+
+    Sinisa Milivojevic - For becoming the new offical maintainer.
+
+    D. Hawkins and E. Loic for their autoconf + automake contribution.
+
+
+See the ChangeLog for further credits, and details about the differences
+between the many versions of this library.
+
+
+Please do not email any of these people with general questions about
+MySQL++. All of us who are still active in MySQL++ development read the
+mailing list, so questions sent there do get to us:
+
+    http://lists.mysql.com/plusplus
+
+The mailing list is superior to private email because the answers are
+archived for future questioners to find, and because you are likely to
+get answers from more people.

Index: ChangeLog
==================================================================
--- ChangeLog
+++ ChangeLog
@@ -1,38 +1,2658 @@
-1999-10-15 Sinisa Milivojevic <sinisa@cytanet.com.cy>
-           
-* Changed version to 1.2					 
-* First offical release. Version 1.0 and 1.1 were releases by Sinisa
-  before I (Kevin Atkinson) made him the offical maintainer,
-* Many manual fixes.
-* Changed README and Changelog
-* Changed source to be compilable by gcc 2.95.xx, tribute to Kevin
-  Atkinson <kevinatk@home.com>
-* Added methods in Connection class which are necessary for
-  fullfilling administrative functions with MySQL
-* Added many bug fixes in code pertaining to missing class
-  initializers , as notified by Michael Rendell <michael@cs.mun.ca>
-* Sinisa Milivojevic <sinisa@cytanet.com.cy> is now the offical
-  maintainer.
-
-
-1999-08-02  Sinisa Milivojevic <sinisa@cytanet.com.cy>
-
-* Changed version to 1.1
-* Added several bug fixes
-* Fixed memory leak problems and variables overlapping problems.
-* Added automake and autoconf support by loic@net.fr
-* Added Makefile for manual
-* Added support for cygwin
-* Added example sinisa_ex (let modesty prevail) which used to crash a 
-  lot when memory allocation, memory leak and overlap problems were
-  present. Smooth running of this example proves that all those bugs are
-	fixed
-* Changed manual
-* Cheanged README
-* Many other smaller things
-
-1999-06-09  Michael Widenius  <monty@monty.pp.sci.fi>
-
-* Changed version to 1.0
-* Added patches from Orion Poplawski <orion@bvt.com> to support the
-  UnixWare 7.0 compiler
+3.0.3, 2008.05.11 (r2284)
+
+    o Fixed query well-formedness handling in Query::store() and use().
+      It was quietly eating these errors, confusing them with the
+      no-results case.
+
+    o Fixed examples/cpool.cpp to build without thread support.
+
+    o No longer hiding all stdint.h typedefs inside namespace mysqlpp.
+
+    o Fixed mysqlpp::String comparisons of empty strings against
+      nonempty strings; if the empty string was on the left hand side,
+      it would succeed because it was only comparing against characters
+      in the empty side, which matches everything.  (Fixes bug 11588.)
+
+
+3.0.2, 2008.04.13 (r2275)
+
+    o Increased float to string conversion precision from 7 to 9 and
+      double from 16 to 17 digits.  Previous values weren't enough
+      near the maximum values that each can hold.
+
+    o Replaced Query's safe bool mechanism with an override of
+      basic_ios::operator void*() to avoid a conflict between the
+      two mechanisms.  As the base class version isn't virtual,
+      this is arguably evil, but it should be harmless in typical use.
+      Besides, testing Query in bool context usually isn't the right
+      thing anyway: test the result set instead.
+
+    o Made ConnectionPool::grab() virtual.
+
+    o Overriding ConnectionPool::grab() and release() in
+      examples/cpool.cpp to show how to do connection-in-use count
+      limiting.  Also, added a few more output indicator states to
+      allow one to better understand program flow.
+
+
+3.0.1, 2008.03.23 (r2263)
+
+    o String objects can now be compared to mysqlpp::null directly.
+
+    o Added a template operator== and operator!= to String, syntactic
+      sugar for the existing String::compare() methods.
+
+    o String::compare() now returns 0 ("equal") when one of the
+      strings is an uninitialized String() (no refcounted buffer)
+      and the other is empty.  It used to consider any initialized
+      string greater than an uninitted one.  An uninitialized String
+      appears empty, though, so this was incorrect.
+
+    o Made Connection::thread_aware(), thread_start() and thread_end()
+      static methods, so they can be called before you create your
+      first connection.  Ditto for DBDriver versions of these methods.
+
+    o Calling Connection::thread_start() and thread_end() in
+      examples/cpool.cpp, as appropriate.  Above changes were necessary
+      to make this work sensibly.
+
+    o Made ConnectionPool::release() virtual, so your pool subclass can
+      override it.
+
+    o Added ConnectionPool::size(), so a subclass can know the current
+      number of extant connections.
+
+    o No longer single-quoting NOW() call generated for default
+      init of DateTime type when building queries from SSQLS objects
+      in Query::insert(), replace() and update().  The template query
+      and stream interfaces of Query treated NOW() correctly already.
+
+    o Fixed a bug that left SSQLS::table_override_ uninitted if
+      you used certain of the generated ctors or set() member
+      functions instead of others used by the examples.  This could
+      cause a crash any time you caused SSQLS.table() to be called,
+      such as when passing the SSQLS to Query::insert().
+
+    o Minor memset bug fixed in test/uds.cpp.  Patch by Dave Jones.
+
+
+3.0.0, 2008.02.29 (r2236) The "Giant Leap Forward" release
+
+    THIS IS NOT A DROP-IN REPLACEMENT FOR MySQL++ v2.x!
+
+    You will have to recompile your program against this version
+    of the library, and you will almost certainly have to make code
+    changes as well.  Please see these sections in the user manual
+    for information on migrating your code to this new version:
+
+    http://tangentsoft.net/mysql++/doc/html/userman/breakages.html#api-3.0.0
+    http://tangentsoft.net/mysql++/doc/html/userman/breakages.html#abi-3.0.0
+
+    o Added ConnectionPool class, primarily to let multithreaded
+      programs share a set of Connection objects safely in situations
+      where it isn't acceptable to have a Connection per thread.
+
+    o Created examples/cpool.cpp to demonstrate this new class.
+
+    o Added RefCountedPointer template, which provides automatic
+      memory management and data sharing.  It's not intended
+      for use outside of MySQL++ itself, but it's the mechanism
+      behind everything below where reference counting is mentioned.
+      I created the initial version of it, but Jonathan Wakely almost
+      completely rebuilt it, and Joseph Artsimovich provided helpful
+      commentary and advice as well.
+
+    o Many improvements to Specialized SQL Structures (SSQLS):
+
+      - Renamed custom* to ssqls*.  There's still a custom.h which
+        #includes ssqls.h for you, but it's only intended to ease
+        the transition to the new name.  It will go away in a future
+        release, probably as soon as v3.1.
+
+      - SSQLSes are finally compatible with Null<>-wrapped types.  This
+        feature is based loosely on the "Waba" patch posted to the
+        mailing list back in the v2.0 days, but extended to allow
+        Null<T> types for key fields.  (The Waba patch only allowed
+        these types in non-key fields.)
+
+      - It's no longer necessary to define a different SSQLS for each
+        different field set you use in queries.  That is to say,
+        you can define an SSQLS for an entire table and store just a
+        subset of the table in it now, with the other fields keeping
+        default values.  Removed examples/custom6.cpp, as custom1.cpp
+        can now demonstrate the same thing, implicitly.
+
+      - An SSQLS's field order no longer has to match the order of
+        fields in the result set it is populated from.
+
+      - As a result of previous, removed sql_create_c_order_* macros;
+        they have no purpose now.
+
+      - Removed order parameters from sql_create_complete_*, which now
+        gives it the same functionality as sql_create_c_names_* so
+        removed the latter, too.
+
+      - Removed "basic" variants of SSQLS creation macros.  They've
+        been unofficially deprecated by dint of being all but
+        undocumented and unexemplified for a very long time now.
+
+      - It's now possible to use mysqlpp::String, Date, DateTime, and
+        Time types in the key field positions in an SSQLS as they
+        now support the necessary comparison interfaces.
+
+      - If you use a floating-point data type in one of the key field
+        positions, it no longer uses exact comparison logic.  Instead,
+        it now does [in]equality comparisons by testing whether the
+        difference between two floating-point values is less than a
+        configurable threshold defaulting to 0.00001.
+    
+      - You can now use 'bool' type in an SSQLS.
+
+      - Renamed _table static member variable in each SSQLS to table_
+        and made it private.  There are now public setter and getter
+        methods, table().
+
+      - Added per-instance table name overriding via instance_table()
+        setter.  table() getter returns static version if this is not
+        set, so it's still a global setting by default.
+
+    o You can now use mysqlpp::null as a template query parameter to
+      get a SQL null.
+
+    o Replaced template ColData_Tmpl<T>:
+
+      - Used to have typedef ColData_Tmpl<std::string> MutableColData.
+        It was used only once within MySQL++ itself, and was never
+        documented as a class for end users.  This one use within
+        the library was a crock, so we just replaced this use with
+        std::string and removed the typedef.
+
+      - This left just one use of ColData_Tmpl<T>, instantiating it
+        with the MySQL++ utility class const_string, basically a
+        clone of std::string with all the mutating features removed.
+        Folded the functionality of const_string into the template,
+        renamed the result to String, and deleted the const_string
+        class.  It'd be a complete std::string replacement -- with
+        SQL-related enhancements -- if it were modifiable, but MySQL++
+        doesn't need it to be modifiable.  Yet, it's still the closest
+        thing MySQL++ has to its own string type; thus the name.
+
+      - Replaced its internal buffer management with a much more
+        clever reference counted scheme.  This shows its greatest
+        advantage in the return from Row::operator[](), which for
+        technical reasons must return by value, not by reference
+        as is more common.  This lets you pass around Strings by
+        value while having the efficiency of reference semantics.
+        This can be important with large return values, like BLOBs.
+
+      - Converting String to numeric types (ints, floats...) uses a
+        new, cleaner system by Jonathan Wakely.  Unless you were
+        abusing weaknesses in the old system, you won't see a
+        difference.  It's just more robust and flexible.
+
+    o Redesigned SQLString:
+
+      - It used to derive from std::string, and while MySQL++'s
+        internals did use it in place of std::string, these places
+        didn't take advantage of the additional features offered
+        by SQLString.  So, replaced all those uses with std::string.
+
+      - All the remaining uses are MySQL++ public interfaces that
+        need to be able to accept any of many different data types,
+        and we want that data to be automatically converted to a
+        SQL-compatible string form.  Because it no longer has the
+        parentage to be a general-purpose string type and MySQL++ has
+        a new contender for that role (String), renamed SQLString to
+        SQLTypeAdapter to reflect its new, limited purpose.  ("STA"
+        for short.)
+
+      - Since we don't have the std::string base class to manage the
+        string buffer any more, using the same reference counted
+        buffer mechanism as String.  In addition to saving code by
+        not creating yet another buffer management mechanism, it means
+        objects of the two classes can share a buffer when you assign
+        one to the other or pass one to the other's copy ctor.
+
+      - Added many more conversion ctors.
+
+      - STA interfaces using the 'char' data type now treat them as
+        single-character strings instead of one-byte integers, as
+        does the Standard C++ Library.
+
+      - Added mysqlpp::tiny_int interfaces to STA to replace the
+        former char interfaces for those needing one-byte integers.
+
+    o As a result of the ColData -> String redesign, removed
+      Row::raw_*().  Before String copies were efficient, this
+      was helpful in accessing BLOB data efficiently.  It was also
+      required back when ColData didn't deal correctly with embedded
+      null characters, but that reason is gone now, too.
+
+    o Row::operator[](const char*) no longer unconditionally throws the
+      BadFieldName exception when you ask for a field that doesn't
+      exist.  It will still throw it if exceptions are enabled, but if
+      not, it'll just return an empty String.  This was necessary to
+      make the SSQLS subset and field order independence features work.
+
+    o Similarly, Result::field_num() returns -1 when exceptions are
+      disabled and you ask for a field that doesn't exist.
+
+    o You can now use the OptionalExceptions mechanism to disable
+      exceptions on const MySQL++ objects.
+
+    o Redesigned query result classes:
+
+      - Instead of Result deriving from ResUse, the two derive from
+        a common base class -- ResultBase -- containing the bits that
+        are truly the same between them.  Before, Result inherited
+        several methods that didn't really make sense for "store"
+        query result sets.
+
+      - Renamed Result to StoreQueryResult and ResUse to UseQueryResult
+        so it's clearer what each is for.
+
+      - Renamed ResNSel to SimpleResult.
+
+      - Made all SimpleResult data members private and hid them behind
+        const accessor functions of the same name.
+
+      - The result set classes all used to be friends of Connection
+        for various lame reasons.  Since they are created by Query,
+        and Query has a good reason for a strong relationship with
+        Connection, moved Connection access out of each result set
+        class into the code in Query that creates that type of result
+        set object.
+
+      - StoreQueryResult now derives from vector<Row> in addition to
+        ResultBase; it used to merely emulate a vector of Rows, poorly.
+        It can now dispose of the MYSQL_RESULT at the end of object
+        construction, because it creates all the Row objects up front
+        instead of on the fly.  And as a result of *that*, operator[]
+        returns by reference instead of by value, operator -> works
+        correctly on iterators, all STL algorithms work, etc., etc.
+
+      - IMPORTANT COMPATIBILITY BREAK: because we used fetch_row()
+        stuff in Result previously, it was okay to index past the
+        end of the result set: you'd just get a falsy Row when you
+        did this, just as happens when doing the same thing in a
+        "use" query.  The simple1 and simple2 examples did this,
+        so it's likely that code exists that takes advantage of this
+        misfeature.  New versions of these examples show how to index
+        through a StoreQueryResult without running past its end.
+
+      - ResUse used to delay creation of its FieldNames and FieldTypes
+        objects until the point of need.  This had several implications
+        for thread and exception safety that we fix by just creating
+        them in the ctor.  If your code is multi-threaded and was
+        avoiding certain usage patterns due to crashes, it's worth
+        trying your preferred way again.
+
+      - Result sets create a few data structures to hold information
+        common to all rows in that set.  The row objects need access
+        to these shared data structures, so on creation each gets
+        a pointer back to the result set object that creates it.
+        This was efficient, but required that a result set object
+        outlive any row objects it creates.  Now these shared data
+        structures are reference-counted, decoupling the lifetime of
+        the child row objects from their result set parent.
+
+      - Copy operations for result sets used to actually be "moves"
+        before, for efficiency.  (MySQL++ itelf only copied result
+        sets in returning them by value from the query execution
+        methods of Query, so this was acceptable if you didn't do
+        anything uncommon with these objects.)  Reference counted
+        data structures allow us to have copy semantics now without
+        sacrificing efficiency.
+
+      - You can now use Query::storein() with an STL container of Row
+        objects now, instead of having to use SSQLSes.  The lifetime
+        issue guaranteed a crash if you tried this before.
+
+      - Removed a bunch of unnecessary alias methods:
+
+        - columns() -> num_fields()
+        - names()   -> field_names()
+        - rows()    -> num_rows()
+        - types()   -> field_types()
+
+      - Renamed several methods for grammar reasons:
+
+        - fields(unsigned int)      -> field(unsigned int)
+        - names(const std::string&) -> field_num(const std::string&)
+        - names(int)                -> field_name(int)
+        - types(int)                -> field_type(int)
+
+      - Removed several "smelly" methods:
+
+        - purge()
+        - raw_result()
+        - reset_names()
+        - reset_field_names()
+        - reset_types()
+        - reset_field_types()
+
+    o Field class used to just be a typedef for the corresponding C
+      API class.  Now it's a real C++ class providing a more MySQL++
+      sort of interface, plus good OO things like information hiding
+      and implementation detail abstraction.  This changes several
+      things about the interface.
+
+    o Fields class was basically a specialized std::vector work-alike
+      for dealing with the C API to get access to MYSQL_FIELD objects
+      and present them as contained Field objects.  New Field type
+      let us replace it with "typedef std::vector<Field> Fields"
+
+    o Major improvements to the quoting and escaping mechanisms:
+
+      - Replaced almost all of the type-specific interfaces in manip.h
+        with a single version taking STA.  The compiler can convert
+        almost anything to STA without losing any information we need
+        for correct quoting and escaping.  This has the side benefit
+        that we can now do correct quoting and escaping for more data
+        types now, including plain C and C++ string types.
+
+      - Fixed a bug in quote_double_only manipulator for String: was
+        using single quotes by mistake.
+
+      - Escaping and quoting only works in instances where MySQL++
+        can tell you're building a SQL query and are using a data type
+        that requires it.  This affects many things, but the one most
+        likely to cause trouble is that inserting MySQL++'s quoting
+        and escaping manipulators in non-Query ostreams is now a no-op.
+
+      - Added escape_string() member functions to Query and
+        SQLQueryParms::escape_string(), and removed the global function
+        of the same name.  Because these are tied indirectly to a
+        Connection object, this also has the effect that escaping is
+        now aware of the current default character set used by the
+        database server.  There's only one case where this isn't done
+        now, and that's when we're disconnected from the server.
+
+      - Previous two items form a trade-off: if your code was depending
+        on MySQL++ to get SQL escaping and it no longer happens for
+        what we consider a good reason, you can build a replacement
+        mechanism using these new functions.  Quoting needs no special
+        support in MySQL++.
+
+      - Removed 'r' and 'R' template query parameter modifiers,
+        which meant "always quote" and "always quote and escape"
+        regardless of the data type of the parameter.  There are no
+        corresponding manipulators (for good reason), so the removal
+        restores symmetry.
+
+    o Created DBDriver class from code previously in Connection and
+      Query to almost completely wrap the low-level MySQL C API:
+
+      - Connection creates a DBDriver object upon connection and
+        passes a pointer to it down to Query objects it creates.
+        In turn, they pass the pointer on to any of their children
+        that need access to the C API.
+
+      - Nothing outside DBDriver calls the C API directly now, though
+        DBDriver leaks C API data structures quite a lot, so this
+        feature doesn't constitute "database independence."  See the
+        Wishlist for what must be done to get to that point.
+
+    o Completely redesigned the connection option setting mechanism:
+
+      - There's now just a single Connection::set_option() method that
+        takes a pointer to the abstract Option base class, and there is
+        an Option subclass for every connection option we understand.
+        Thus, type errors are now caught at compile time instead of
+        at run time.
+
+      - Replaced Connection::enable_ssl() with SslOption class.
+
+      - Enabling data compression and setting the connection timeout
+        are no longer set via parameters to Connection interfaces.
+        These are now set with CompressOption and ConnectTimeoutOption.
+
+      - Similarly, removed client_flag parameters from Connection's
+        ctor and connect() method and added corresponding Option
+        subclasses.  There's about a dozen, so rather than list them
+        here, look for similarly-named classes in lib/options.h.
+
+    o Added Connection::count_rows() to execute "SELECT COUNT(*) FROM
+      tablename" queries for you.
+
+    o Moved Connection::affected_rows(), info() and insert_id() methods
+      to class Query, as they relate to the most recently-executed
+      query, not to the connection.
+
+    o Several method name changes in Connection:
+
+      - client_info()   -> client_version()
+      - host_info()     -> ipc_info()
+      - proto_info()    -> protocol_version()
+      - server_info()   -> server_version()
+      - stat()          -> status()
+
+    o Removed Connection::api_version().  It does the same thing as
+      client_version().
+
+    o Lots of changes to Date, DateTime, and Time classes:
+
+      - If you use the default constructor for DateTime and don't
+        subsequently set its year, month, day, hour, minute or second
+        data members to nonzero values, it becomes the SQL function
+        "NOW()" in a query string.  You can also use DateTime::now()
+        as syntactic sugar for this.
+
+      - As a result of above, had to hide all of DateTime's data
+        members behind accessor functions, to keep the state of the
+        object consistent.  (If it's initialized as "now" and you
+        give it an explicit year value, say, it is no longer "now",
+        so the setter has to clear the now-flag.)  There are getters
+        and setters for year, month, day, hour, minute and second,
+        all named after the member.
+
+      - Did the same for Date and Time for consistency, even though it
+        isn't technically required.
+
+      - The sql_timestamp typedef now aliases DateTime instead of Time.
+
+      - Renamed template class DTbase<T> to Comparable<T>.  The fact
+        that it's the common base class of all date and time classes
+        is irrelevant; making subclasses comparable is what it does,
+        so that's what it should be named after.
+
+      - Added a DateTime ctor taking discrete year, month, day, hour,
+        minute, and second values.
+
+      - Implicit conversion from stringish types to the date and time
+        types is no longer allowed.  This is part of the "Waba"
+        Null<T> patch mentioned above; allowing implicit conversions
+        would break this new feature.
+
+      - Added operator std::string and str() methods to all of these
+        classes.  Adding this to the existing operator << support, you
+        now have several ways to convert these objects to string form.
+
+      - Added time_t conversion to Date and Time classes.  DateTime
+        already had it, since it's more legitimate to convert time_t
+        to DateTime, but you could already "slice" it with something
+        like Time(DateTime(time(0))) so there's no point pretending
+        you can't get from time_t to Date or Time.  Might as well
+        legitimize it.
+
+    o Improved tiny_int class:
+        
+      - Turned it into a template parameterized on the value type so
+        you can get both signed and unsigned TINYINTs
+
+      - Changed the sql_tinyint and sql_tinyint_unsigned typedefs to
+        use mysqlpp::tiny_int<VT> instead of raw chars
+
+      - Added a bool conversion ctor and operator, and typedef'd it
+        to sql_bool and sql_boolean to match MySQL server behavior
+
+    o Added many more sql_* typedefs.  We now have a typedef for every
+      type the MySQL server knows about, including those it supports
+      just for compatibility with other database servers.
+
+    o Changed the sql_*int* typedefs to use integer types of the same
+      size as the MySQL server.  (Run test/inttypes.cpp to test it.)
+
+    o Added copy ctor and assignment operator to Row.
+
+    o Row::operator[]() takes int now instead of unsigned int.
+      This finally (!) makes it possible to say row[0] without the
+      compiler giving an ambiguous overload error.
+
+    o Changed all uses of row.at(0) in the examples to row[0]
+
+    o Added operator[] to all classes that only had at().
+
+    o Query now automatically resets itself unless the query fails
+      or you're using template queries.  In either case, the contents
+      of the query's internal buffers are considered precious,
+      either for debugging, or future queries.  Except when using
+      template queries, this means you may be able to avoid calling
+      Query::reset() entirely.  It's still safe to call reset()
+      as before, just unnecessary most of the time.
+
+    o Removed reset_query parameter from all Query methods.  It was
+      almost completely broken before, and above change does what
+      was really wanted to begin with.
+
+    o Query::store_next() and Result::fetch_row() no longer throw
+      the EndOfResults and EndOfResultSets exceptions; these are not
+      exceptional conditions!  These methods simply return false now.
+
+    o Removed examples/usequery.cpp: there's no essential difference
+      between what it did and what examples/simple3.cpp does now as
+      a result of the previous change.
+
+    o Added Query::exec(void), paralleling Query::execute(void).
+
+    o Removed Query::preview().  The most direct replacement is str(),
+      which has always done the same thing.
+
+    o You can now insert a Query object into an ostream to get a copy
+      of the built query.  This means Query::str() is only necessary
+      when using template queries.
+
+    o Removed overloads of Query::execute(), store(), and use()
+      that take const char*.  It was redundant because const char*
+      converts implicitly to STA, for which overloads already exist.
+
+    o Renamed Query::def to Query::template_defaults to make its
+      purpose clearer.
+
+    o Query::error() now returns const char*, not a std::string by
+      value.  There's no point in making a copy of the error string.
+      The method is now const as well, as it doesn't change the
+      Query object.
+
+    o Added Query::errnum(), which just wraps Connection::errnum().
+
+    o Added error number parameters and accessor functions to BadQuery,
+      ConnectionFailed and DBSelectionFailed exceptions, to preserve
+      the state of Connection::errnum() at the point of the exception,
+      so you don't have to rely on this value remaining unchanged
+      during the exception throw process.  All places that use these
+      exceptions now include this value where possible.  Thanks for the
+      initial patch go to Jim Wallace.
+
+    o Removed Lockable mechanism from Connection and Query; it was
+      conceptually flawed.  See the new user manual chapter on
+      threading for advice on using MySQL++ safely without locking.
+      There is mutex locking now in ConnectionPool, but that's it.
+
+    o Connection::query() now takes an optional query string, allowing
+      the returned Query object to start off with a value.  Especially
+      useful when the query string is static, either because it's
+      a simple query or because it's a template.  You can now build
+      chains like "if (conn.query("CREATE INDEX ...").exec()) { ..."
+
+    o Added Connection::thread_aware(), thread_end(), thread_id()
+      and thread_safe().  See user manual's threading chapter for
+      explanations.
+
+    o Renamed "success" data members in Connection, Query and
+      SimpleResult (neƩ ResNSel) to "copacetic_", making them private
+      if they weren't before.  This better reflects their actual
+      use, which isn't to say that there has necessarily been actual
+      success, but rather that everything's okay with the object.
+
+    o Removed success() member functions from above classes.  All can
+      be tested in bool context to get the same information.
+
+    o Replaced all operator bool()s in MySQL++ classes with safer
+      alternatives.  See http://www.artima.com/cppsource/safebool.html
+      Thanks to Jonathan Wakely for much helpful commentary, advice,
+      and code used in these mechanisms.
+
+    o Decoupled Connection::copacetic_ from Connection::is_connected_.
+      It is now possible for the object to be copacetic without being
+      connected.  However, if it tries to connect and fails, then
+      it is not copacetic.  If it is copacetic and not connected, it
+      means we haven't even tried to connect yet, a useful distinction.
+
+    o Collapsed Connection's host, port, and socket_name down into
+      a new combined 'server' parameter which is parsed to determine
+      what kind of connection you mean.  These interfaces are still
+      compatible with v2.3 and earlier up through the port parameter.
+      There are differences beyond this.
+
+    o Added TCPConnection, UnixDomainSocketConnection and
+      WindowsNamedPipeConnection subclasses for Connection giving
+      simpler construction and connect() method interfaces for
+      instances where you know what kind of connection you want at
+      compile time.
+
+    o Changed Connection::ping() return value from int to bool.
+
+    o Renamed NullisNull to NullIsNull -- capital I -- and similar for
+      NullisZero and NullisBlank.
+
+    o It's now a compile-time error to try to convert a MySQL++
+      representation of a SQL null to any other data type, rather
+      than a run-time error as in previous versions.  Removed
+      BadNullConversion exception as a result.
+
+    o Way back in v1.7.x we used the BadQuery exception for all kinds
+      of exceptional conditions, not just bad queries.  Replaced
+      most of these in v2.0.0 with new dedicated exceptions, but a
+      few remained:
+      
+      - Errors that occur during the processing of a "use" query after
+        the query itself executes correctly now throw UseQueryError.
+        It's not a "bad query", because the query executed
+        successfully.  It just choked during subsequent processing,
+        so it's a different exception.  Thanks for this patch go to
+        Jim Wallace.
+
+      - Replaced BadQuery exceptions thrown in Row constructor due
+        to bad ctor parameters with new ObjectNotInitialized exception
+        This is also Jim Wallace's work.
+
+    o The examples now all use getopt() type command line options
+      instead of positional options.  This makes it possible to
+      pass options in any order, leave at their default options that
+      used to be in the middle of the sequence, and offer different
+      subsets of options for different programs.  Also allows for
+      special internal-use options, like -D passed by dtest to let
+      examples change their behavior when run under dtest to produce
+      only predictable output.
+
+    o Split old libutil functionality into two modules, one holding
+      all the "print data" functions, and another holding all the
+      command line parsing stuff.  This makes it easier for newbies
+      to ignore the command line stuff, treating it like a black box.
+      The wish to understand the "print data" routines is much more
+      common, so the two needed to be disentangled.
+
+    o Renamed examples' libutil to libexcommon.
+
+    o Removed connect_to_db() libutil function.  It combined command
+      line parsing, which users don't care about, with database
+      connection establishment, which they do care about.  Now the
+      examples just call out to libexcommon to parse the command
+      line, and use the values they get back to explicitly make the
+      connection, so it isn't hidden.
+
+    o Removed cchar and uint typedefs.
+
+    o Redesigned dbinfo example's output to be easier to read.
+
+    o Fixed an output formatting bug created in 2.3.0 that caused the
+      tabular output from examples to not line up.
+
+    o Renamed examples/tquery.cpp to tquery1.cpp.  Created tquery2.cpp
+      to demonstrate passing parameters via a SQLQueryParametrs object
+      instead of discretely.  Created tquery3.cpp for testing unquoted
+      template parameters, such as integers.
+
+    o Renamed fieldinf1.cpp example to fieldinf.cpp, and simplified
+      its output so it can be part of the dtest sequence.
+
+    o Renamed examples/xaction.cpp to transaction.cpp.  It created too
+      much cognotive dissonance whenever thinking about both it and
+      lib/transaction.cpp.
+
+    o Added examples/deadlock.cpp, to test handling of exceptions due
+      to server-side transaction deadlock detection.  Also added
+      code to resetdb to create a table needed to test this.
+      Initial version created by Jim Wallace to test the value of
+      all his BadQuery exception work, with reworking by me.
+
+    o Greatly expanded dtest suite.  Primary change is that we now
+      have a handful of unit tests, where in v2.3.2 we only tested
+      a subset of the examples.  Still very low coverage ratio,
+      but it's a big improvement.
+
+    o Optimized #includes, especially in lib/*.h to reduce
+      dependencies and thus compile time when one of these changes.
+
+    o Fixed a typo in RPM filename generation that prevented -devel
+      RPM from recognizing that the corresponding MySQL++ library
+      RPM was installed.
+
+    o RPM spec file improvements by Remi Collet.
+
+    o Renamed NO_LONG_LONGS to MYSQLPP_NO_LONG_LONGS to avoid a risk
+      of collision in the global macro namespace.
+    
+    o First cut at Xcode2 project support.  Testing needed!
+
+    o Debug build of library on VC++ and Xcode have a _d suffix now
+      so you can have both versions of the library installed without
+      conflict.
+
+    o Moved the VC++ 2003 project files into a new vs2003 subdirectory
+      because there are so many of them.  Also created vs2005
+      subdirectory for VC++ 2005 and 2008 compatible project files.
+      2005 makes an even bigger mess of the directory containing
+      the .sln file, so the incentive is bigger.  Plus, we have to
+      disable several things to get VC++ 2003 to build MySQL++ now,
+      so we need a special 2005+ version of the project files for a
+      complete build, if the user has one of the newer compilers.
+
+    o ...plus dozens of small bug fixes and internal enhancements,
+      many documentation improvements, and expansion of support for
+      newer operating systems and compilers.
+
+
+2.3.2, 2007.07.11 (r1669)
+
+    o Previous release's const_string change caused more problems
+      than it fixed.  This release contains the real fix. :)
+
+    o New Connection::set_option() handling deals with the multi
+      statements option correctly again.  examples/multiquery now
+      runs again as a result.
+
+    o Added new unit testing script, called dtest.  See the
+      HACKERS file for details.  (This tool caught the previous
+      two problems!)
+
+    o Squished a GCC pedantic warning.  Thanks for the patch go to
+      Andrew Sayers.
+
+
+2.3.1, 2007.07.10 (r1659) The "After the Fireworks" release
+
+    o const_string objects now keep a copy of their data, not
+      just a pointer to it.  This is less efficient, but necessary
+      to allow SSQLS to work with BLOBs.  Without this, we were
+      seeing segfaults due to accessing freed memory pointed to
+      by the const_string, because the underlying object went
+      out of scope.
+
+    o Fixed many more potential embedded null handling problems
+      in manip.h.
+
+    o MySQL++ can now optionally reference MySQL C API headers as
+      being in a mysql subdirectory, a common thing on *ix systems,
+      by defining MYSQLPP_MYSQL_HEADERS_BURIED before #including
+      mysql++.h.
+
+    o Restored ColData_Tmpl<T>::get_string(), removed in v2.3.0,
+      along with warnings in the docs saying why you don't want
+      to use it, and what your alternatives are.
+
+    o VC++ and MinGW builds now define the HAVE_MYSQL_SSL_SET
+      macro, which lets you use the C API's SSL features.
+      This assumes your C API library does actually have these
+      features enabled, which is the case with the official binary
+      releases on Windows.  (Builds on *ix systems continue to
+      test for these features at configure time.)
+
+    o Fixed simple examples-only Makefile generation, for RPMs.
+
+
+2.3.0, 2007.07.02 (r1645)
+
+    o Added Query::for_each() and Query::store_if() methods
+      proposed by Joel Fielder, and added examples for each.
+
+    o It's now possible to store BLOB data in an SSQLS.  It's not
+      foolproof, so added a section to the user manual (5.9) to
+      document the method.  Also, changed examples/cgi_jpeg to use
+      this new mechanism, instead of the ugly "raw row data" method
+      it used to use.
+
+    o Revamped Connection::set_option() handling.  These options
+      used to be queued up, and applied only just before actually
+      establishing the connection.  This made error reporting less
+      helpful because the diagnostic was separated from the cause.
+      Plus, the error messages were misleading to begin with.  Now,
+      set_option() takes effect immediately if the connection is not
+      yet up (excepting one special option that can actually be set
+      after the connection is up) and issues better diagnostics when
+      it detects errors.
+
+    o Connection::connect() used to set a few options in such a
+      way that the user couldn't override them.  Now it's smart enough
+      to set them with the desired default values only when we see
+      that the user hasn't given them other values.
+
+    o SQLString can now be initialized from a mysqlpp::null,
+      giving a "NULL" string.  This is useful for template queries.
+      Patch by Michael Hanselmann.
+
+    o resetdb error message about mixing library and header version
+      numbers is now more explicit.
+
+    o Changed BadConversion exception's "what" message text to be
+      more like the other exceptions.  The inconsistency lead one
+      to incorrectly copy-paste code from another exception handler,
+      expecting it to behave the same way.  Now it does.
+
+    o Added Row::raw_size(), as a shortcut for Row::at().size().
+
+    o ssqls-pretty now detects when it's being run from within
+      the MySQL++ distribution tree and gives a different -I flag
+      to the compiler, so that it picks up the distribution headers
+      instead of those that may be on the system already.
+
+    o The quote manipulator now works for char[] correctly.
+      Thanks for this patch go to Andrew Sayers.  (It's always
+      worked for char*, but C++ doesn't consider that to be the
+      same type, so it used the generic quote handling path,
+      which doesn't do anything for char[].)
+
+    o Fixed a build bug on older Solaris versions where the
+      test for the C API library was erroneously failing, stopping
+      the configuration process.
+
+    o Simplified mysql_shutdown() level argument detection.
+      Already had to do a version number ifdef check for the
+      Windows case, so there's really no point to doing it with
+      autoconf on Unixy platforms.  Moved version number check
+      into lib/connection.cpp, and nuked the separate autoconf and
+      Windows tests.
+
+    o Removed dependency of sql_types.h on myset.h and (indirectly)
+      datetime.h.  Now we only define sql_* typedef aliases for those
+      MySQL++ types if the headers are included before sql_types.h.
+
+    o Fixed a typo in one of the storein_sequence() template
+      overloads, which is apparently rarely (or never?) used, because
+      no one reported the compiler error you'd get if you tried.
+
+    o Fixed a few more embedded null handling problems.
+
+    o ColData used to keep two copies of all data it held.
+      Now it keeps just one.
+
+    o Fixed install.bat script to track the unified Bakefile change
+      and the lack of separate debug and release builds under MinGW.
+
+    o Yet another STLport + Query memory leak fix.
+
+    o Squished a warning in newer GCCs having to do with identifier
+      shadowing.  Patch by Jonathan Wakely.
+
+    o Fixed a null-termination bug in Query::parse().  If you
+      somehow constructed a query string without a terminating null
+      character, then tried to parse it as a template query, it could
+      walk off the end of the string.  Patch by Worster Chen.
+
+    o Removed MYSQLPP_EXPORT tag from FieldNames and FieldTypes
+      class declarations, as this can cause problems in programs
+      that use vector<string> in VC++.  It has to do with multiply
+      defined templates, since these classes derive from that
+      template, and VC++ can't resolve the conflict without help.
+      Since these classes aren't actually used outside the library,
+      this shouldn't cause a problem.  Patch by Nils Woetzel.
+
+    o Partial fix to Doxygen PDF build on RHEL4 and 5.  Needs
+      hand-coaxing to complete successfully on RHEL4, and doesn't
+      yet work at all on RHEL5.
+
+    o Shortened the "no*" options to the bootstrap script, so that
+      the usage message fits on a single line.
+
+    o Added "nodoc" bootstrap script option, for disabling the
+      documentation build during the dist target build.  Allows for
+      building binary RPMs on CentOS 5.0, where doc building is
+      currently broken.
+
+    o Removed the updel example program.  It was kind of silly,
+      and if you were to rewrite it today, you'd use for_each() anyway.
+
+    o Lots of documentation improvements.
+
+
+2.2.3, 2007.04.17 (r1538) The "Tax Day" release
+
+    o Previous version left examples/vstudio/* out of the tarball
+      by accident.
+
+    o Improved generation of RPM temporary build directory path
+      name generation.  Was using a hacked variant of the Fedora
+      Packaging Guidelines' second best choice.  Now we're using
+      the choice they recommend most highly, without changes.
+
+    o Removed unnecessary resources from vstudio/wforms example.
+
+    o Minor URL fix in refman
+
+
+2.2.2, 2007.04.13 (r1526) The "Nervousmaking Friday the 13th" release
+
+    o More small fixes to embedded null handling in Query.
+
+    o Fixed a bug in single-parameter template query handling.
+
+    o Added tquery example, to demonstrate proper use of template
+      queries.  Previously, resetdb was the only exemplar, and
+      it wasn't really suited for that.  This example also tests
+      the previous item.
+
+    o Added examples/vstudio/mfc, allowing us to improve the way
+      we demonstrate Unicode handling.  Old way wasn't realistic.
+      On *ix, people will depend on the terminal code to handle
+      UTF-8.  On Windows, users are almost certain to be writing
+      a GUI program, which requires different Unicode handling
+      than the old examples showed.
+
+    o Removed explicit Unicode conversion stuff from command line
+      examples, and reworked the Unicode chapter in the user
+      manual.
+    
+    o Added examples/vstudio/wforms to show integration with
+      C++/CLI and Windows Forms.  Documented this in README.vc.
+
+    o Rewrote load_file and cgi_image examples to be more
+      useful, renaming them to load_jpeg and cgi_jpeg along
+      the way.  Also, resetdb now creates a second table in the
+      sample database for these two examples' use.  Also, added
+      examples/logo.jpg to the distribution as sample data for
+      these examples.
+
+    o Limited the ostream base class casting stuff in Query to
+      VC++ 2003, which is the only platform that really needed it.
+      VC++ 2005 emits a warning with that hack in place, and on
+      other platforms it's just replicating work that the compiler
+      does already.
+
+    o Added library version information to main library target
+      so that systems that version shared libraries work as
+      expected.  Thanks for this patch go to Jack Eidsness.
+
+    o Merged much of the diffs between Remi Collet's RPM spec file
+      into the official one.
+
+    o Reorganized the doc subdir a bit.  Generated HTML is now all
+      under doc/html instead of scattered under other subdirs,
+      and renamed doc/README.mysql++ to doc/README.manuals.
+
+    o Improvements to top-level manual building make targets:
+      manuals now only rebuild at need, it's easier to request
+      a rebuild of all manuals, and we force a rebuild attempt
+      before building the distribution tarball so we don't ship
+      outdated manuals.
+
+    o Added ability to run examples under gdb using exrun,
+      using same mechanism as we currently have for valgrind.
+      Thanks for this patch go to Michael Hanselmann.
+
+    o Added "Important Underlying C API Limitations" chapter to the
+      user manual, to cover problems we keep seeing on the
+      mailing list that are the result of ignorance of the way
+      libmysqlclient behaves, not bugs MySQL++ is really in a
+      position to fix.
+
+
+2.2.1, 2007.02.28 (r1433)
+
+    o Fixed the new localtime() alternative selection code
+      for VS2003 and various uses of STLport.
+
+    o No longer inserting a null character into the query stream
+      on calling one of the preview() functions.  This was harmless
+      in v2.1, which used C strings more extensively, but began
+      causing problems in v2.2 due to its wider use of C++ strings.
+
+    o Fixed a bug in the Connection copy ctor where it didn't
+      completely initialize the object.
+
+    o Optimized Query::preview_char() a bit.  Patch by Jonathan
+      Wakely.
+
+    o Reordered directory list used by autconf when locating the
+      MySQL C API library.  The list is now ordered with the
+      most likely locations for the library first, so we're less
+      distracted by incorrect libraries.  This fixes a specific
+      build error under RHEL4 with recent versions of MySQL 5.0.
+
+
+2.2.0, 2007.01.23 (r1417)
+
+    o ColData, const_string, and SQLString can now be constructed
+      with an explicit length parameter.  Furthermore, Query
+      class's execute(), store() and use() call chains terminate
+      in a version taking an explicit length parameter, instead
+      of one taking a simple C string.  Together, this means
+      that it's now easier to handle data from the SQL server
+      containing nulls.  The library is almost certainly not yet
+      capable of handling embedded nulls in all cases, but this
+      is a big first step towards that.
+
+    o Can now construct a DateTime object from a time_t, and
+      convert a DateTime back to a time_t.  Patch by Korolyov Ilya.
+
+    o Changed the way we're handling exported functions in the
+      Windows DLL case so that it works more reliably under MinGW.
+
+    o Added proper copy semantics to Connection, so that you get a
+      new connection with the same parameters, not just a bitwise
+      copy of the object.
+
+    o Using an explicitly thread-safe variant of localtime() for
+      time conversions where one is available.
+
+    o Removed ListInsert template from myset.h.  This wasn't used
+      within the library, and was never documented, so I'm betting
+      that no one actually uses it.
+
+    o Result::copy() was not copying the exception flag in
+      all cases.  Fix by Steven Van Ingelgem.
+
+    o Added exrun shell script and exrun.bat files to distribution,
+      to avoid linkage errors when running the examples while
+      you still have an older version of MySQL++ installed.
+
+    o Renamed MYSQLPP_LIB_VERSION to MYSQLPP_HEADER_VERSION, as
+      what it really encodes is the version number in the mysql++.h
+      file you're using, not the actual library version number.
+
+    o Added mysqlpp::get_library_version(), which returns the
+      library version number at build time.  Between this and
+      the header version constant, you can check that you're not
+      mixing MySQL++ header and library versions.
+
+    o resetdb example uses these new version number affordances to
+      double-check that you're not mixing libraries and headers
+      from different versions.  This happens easily unless you
+      take care of it (such as by using exrun) when you have one
+      version of MySQL++ installed and you're trying to build and
+      test a new version without blowing away the old one first
+      or overwriting it.
+
+    o No longer using recursive Makefiles on Unixy platforms
+      or split lib + examples project files on VC++.  Everything is
+      handled by a single top-level Makefile or project file, which
+      is simpler for the end user, and makes better dependency
+      management possible.
+
+    o When looking for the MySQL C library on systems using
+      autoconf, looking in .../lib64 wherever we are also looking
+      in .../lib.
+
+    o RPM build process no longer depends on Bakefile.  It means
+      you have to build the examples when building an RPM even
+      though they're never used within the RPM, but it's a better
+      tradeoff in my opinion.
+
+    o Updated include and library paths on Windows to reflect
+      changes in the most recent MySQL installers.
+
+    o Merged lib/defs.h and lib/platform.h into new file,
+      lib/common.h.  Just cleans up the library internals.
+
+    o Fixed build errors on Windows due to recent changes in MySQL.
+
+    o Fixed a few memory leaks and double-deletes in Query class.
+
+    o Fixed compatibility with STLPort's string implementation.
+      Patch by dengxy at cse.buaa.edu.cn.
+
+    o Fixed a compatibility problem between Set<> template and
+      SSQLS.  Patch by Korolyov Ilya.
+
+    o Fixed build bug in SQLQueryParms due to a character
+      signedness issue on PowerPC with GCC.  Patch by Michael
+      Hanselmann.
+
+    o ~Transaction() can no longer throw exceptions.  It'll just
+      quietly eat them, to avoid program termination.  Fix
+      suggested by Alex Burton.
+
+    o Fixed thread safety testing in autoconf case, accidentally
+      broken during v2.1.0 development cycle.
+
+    o Using Doxygen 1.5.1 to generate documentation.
+
+
+2.1.1, 2006.04.04 (r1289)
+
+    o MinGW and Cygwin will now build and link to mysqlpp DLLs.
+
+    o Fixed bug in Query, causing it to initialize the "throw
+      exceptions" flag incorrectly.  Thanks for this patch go to
+      Joel Fielder.
+
+    o Added -v flag for custom.pl script, which turns off the
+      multiply-defined static variable fix.  Needed for VS 2003,
+      which doesn't support variadic macros.  Also, added
+      a diagnostic to detect the need for the -v flag, and
+      suppressed the test for this feature in examples/util.cpp.
+
+
+2.1.0, 2006.03.24 (r1269)
+
+    o Converted automake and makemake files to their equivalents in
+      Bakefile format.
+
+    o Added the Transaction class, which makes it easy to use
+      transaction sets in MySQL++.
+
+    o Added xaction example to test new Transaction class.
+
+    o Resetdb example now creates its example table using the
+      InnoDB storage engine, in order to test the new transaction
+      support.  Resetdb also declares the table as using UTF-8
+      text; this doesn't change anything, but it does correctly
+      document what we're doing.
+
+    o Added sql_types.h header, containing C++ typedefs
+      corresponding to each MySQL column type.  Using those new
+      types in the type_info module, and in the SSQLS examples.
+
+    o Replaced the way we were handling the template query
+      version of Query member functions, to allow an arbitrary
+      number of template query parameters.  By default, we
+      now support 25 parameters, up from the old limit of 12.
+      It's now possible to change just one number, run a script,
+      and have a new limit.
+
+    o Connection class does a better job of returning error
+      messages if you call certain member functions that depend
+      on a connection to the server before the connection is
+      established.
+
+    o Updated libmysqlclient.def for newer versions of MySQL.  (Fixes
+      build errors having to do with mysql_more_results() and
+      mysql_next_result().
+
+    o Replaced final use of strcpy() with strncpy().
+
+    o custom.pl now runs without complaint in strict mode, with
+      warnings turned on.  Thanks for this patch go to "Waba".
+
+    o Fixed a bug in custom.pl where incorrect code would be
+      generated for some SSQLS set() methods.  Thanks for this
+      patch go to "Waba".
+
+    o SSQLS structures now support long and unsigned long fields.
+      Thanks for this patch go to "Waba".
+
+    o It's now possible to put SSQLS definitions in a header
+      file used by multiple modules in a program without
+      getting multiple static member definition errors.  See the
+      documentation for details.  Thanks for this patch go to
+      Viktor Stark.
+
+    o Moved the definition of the 'stock' SSQLS out of the
+      custom*.cpp example files and into a new stock.h file.
+      Also, #including that file in the util module to test out
+      the new SSQLS multiple static definition fix.
+
+    o Using all of the digits of precision guaranteed by the
+      IEEE 754 spec when stringizing floating point numbers
+      to build queries.  Previously, we would use the platform
+      default, which can be as few as 6 digits.
+
+    o Removed lib/compare.h.  Not used within the library, never
+      documented, and nobody seems to want to defend it.
+
+
+2.0.7, 2005.11.23 (r1147)
+
+    o Added explicit mysqlpp namespace qualifiers to generated code in
+      custom*.h so you can use SSQLS in places where it doesn't make
+      sense to say "using namespace mysqlpp" before the declaration.
+      Also updated some of the examples to not have this "using"
+      declaration to make it clear to users that it isn't needed, if you
+      want to use explicit namespace qualifiers as well.  Thanks for
+      this patch to Chris Frey.
+
+    o Removed an apparently useless unlock() call from ResUse; there is
+      no nearby lock() call, so if this unlock() is in fact necessary,
+      it shouldn't be here anyway, because the two calls should be
+      nearby each other.  Thanks for this patch to Chris Frey.
+
+    o Fixed Query ostream initialization bug affecting SunPro CC (at
+      least).  While this bug violates the Standard, it doesn't affect
+      many real compilers because they don't enforce this rule.  Fixed
+      by Chris Frey.
+
+    o Previously, we only used the C99 style "long long" support when
+      building under GNU CC.  This is now the default.  This should
+      allow the code to work under SunPro CC.
+
+    o Added another dynamic cast needed for proper Query ostream
+      subclass overloading under VC++.  (7.1 at least...)
+
+    o Detecting whether MySQL is built with SSL support on platforms
+      using autotools.  Needed on some old Sun systems, for instance.
+      Thanks for this patch to Ovidiu Bivolaru.
+
+    o Fixed a potential memory bug in ColData's conversion to SQL null.
+
+    o Many minor packaging tweaks.  (README clarifications, file
+      permission fixes, better adherence to GNU packaging standards,
+      etc.)
+
+    
+2.0.6, 2005.09.28 (r1123)
+
+    o Fixed makemake.bat so it works on cmd.exe, not just 4NT.
+
+    o Documentation fixes.
+
+
+2.0.5, 2005.09.13 (r1114)
+
+    o Visual C++ build now requires GNU make.  It is tested to work
+      with either the Cygwin or the MinGW versions.  The previous
+      version of MySQL++ used nmake.  This change enabled the
+      following features:
+
+        o Debug and Release versions are both built into
+          separate subdirectories.
+
+        o Dependency tracking for release version works
+          correctly now.  (Previously dependencies worked
+          only for debug version.)
+
+        o 'make clean' removes release version binaries
+          in addition to debug versions.
+
+    o MinGW makemake support updated to support new release/debug
+      subdirectory system.  This is probationary support, since
+      this code currently can't be built as a DLL.  As a result,
+      it is no more useful than the Cygwin version, for licensing
+      reasons.
+
+    o Several fixes to allow building on Solaris 8.  These fixes may
+      also help on other SVR4-derived systems.
+
+    o Removed Borland C++ makemake support, because this version
+      of the library does not work completely, and there seems
+      to be almost no user interest in fixing it.
+      
+    o Clarified "Handling SQL Nulls" section of user manual's
+      Tutorial chapter.
+
+
+2.0.4, 2005.08.29 (r1076)
+
+    o Made mysql_shutdown() second parameter autoconf check less
+      sensitive to compiler pedantry.
+
+    o VC++ library Makefile is now smart enough to re-create the
+      import library, if it is deleted while leaving the DLL alone.
+
+    o Added libmysqlclient.def to tarball.
+
+    o Reworked most of the top-level README* files.
+
+    o Renamed LGPL file to LICENSE.
+
+
+2.0.3, 2005.08.25 (r1060)
+
+    o Visual C++ makemake system updated to build both debug and
+      release versions of library DLL.
+
+    o Fixed bug in simple1 example that caused crashes on Windows.
+
+    o Doing UTF-8 to ANSI text translation in simple examples now.
+
+    o Previous two releases built libmysqlpp with wrong soname on
+      autotools-based systems.  Fixed.
+
+
+2.0.2, 2005.08.18 (r1050)
+
+    o Fixes to makemake system for cmd.exe.
+
+    o Fixed the case where the system's C++ library includes an slist
+      implementation in namespace std.
+
+
+2.0.1, 2005.08.17 (r1046)
+
+    o Added new simple1 example, showing how to retrieve just one
+      column from a table.  Old simple1 is now called simple2, and
+      simple2 is likewise shifted to simple3.
+
+    o Added custom6 example, showing how to do the same thing with
+      SSQLS.
+
+    o Updated user manual to cover new examples.
+
+    o Was accidentally shipping Subversion crap with tarball.  Fixed.
+
+
+2.0.0, 2005.08.16 (r1031) The "Excess Hair Removal" release
+
+    THIS IS NOT A DROP-IN REPLACEMENT FOR MySQL++ v1.7!
+
+    At minimum, you will have to recompile your program against
+    this library.  You may also have to make code changes.
+    Please see the "Incompatible Library Changes" chapter of
+    the user manual for a guide to migrating your code to this
+    new version:
+
+        http://tangentsoft.net/mysql++/doc/html/userman/breakages.html
+
+    o The library's shared object file name (soname) scheme has
+      changed.  (This mainly affects POSIX systems.)
+      
+      The soname for the last 1.7.x releases of MySQL++ was
+      libmysqlpp.so.4, meaning the fourth version of the library's
+      application binary interface (ABI).  (The first ABI version
+      in this scheme was that provided by 1.7.9.)  MySQL++
+      2.0.0's soname is libmysqlpp.so.2.0.0.  Since the dynamic
+      linker setup on some systems will create a symlink to
+      that file called libmysqlpp.so.2, it's possible that this
+      library could be confused with that for MySQL++ 1.7.19
+      through .21, which also used this number.  Do not install
+      this library on a system which still has binaries linked
+      against that version of the library!
+
+      The new scheme is {ABI}.{feature}.{bug fix}.  That is,
+      the first number changes whenever we break the library's
+      binary interface; the second changes when adding features
+      that do not break the ABI; and the last changes when the
+      release contains only internal bug fixes.  This means
+      that we will probably end up with MySQL++ 3.0 and 4.0 at
+      some point, so there will be further soname conflicts.
+      Hopefully we can put these ABI changes off long enough
+      to avoid any real problems.
+
+    o autoconf now installs headers into $prefix/include/mysql++,
+      instead of $prefix/include.  If you were using the
+      --includedir configure script option to get this behavior
+      before, you no longer need it.
+
+    o Linux binary RPMs will henceforth include only the
+      libmysqlpp.so.X.Y.Z file, and create any short names
+      required, to allow multiple versions to be installed at
+      once.  Currently, you cannot install two MySQL++ library
+      RPMs at once, because they both have /usr/lib/libmysqlpp.so.X,
+      for instance.
+
+    o Replaced the Visual C++ and Borland C++ project files with
+      a new "makemake" system, which creates Makefiles specific
+      to a particular toolchain.  This new mechanism also supports
+      MinGW and generic GCC-on-*ix.  This was done partly to reduce
+      the number of places we have to change when changing the
+      file names in MySQL++ or adding new ones, and partly so we're
+      not tied to one particular version of each of these tools.
+
+    o VC++ Makefiles create a DLL version of the library only
+      now, so there's no excuse for LGPL violations now.
+      This same mechanism should make DLL builds under other
+      Windows compilers easy.
+
+    o Added Connection::enable_ssl(), which enables encrypted
+      connections to the database server using SSL.
+
+    o Connection::create_db() and drop_db() now return true on
+      success, not false.
+
+    o Connection::create_db() and drop_db() use Query::exec()
+      now, for efficiency, rather than Query::execute().
+
+    o Removed Connection::infoo().  Apparently just there to
+      save you from a typo when calling the info() method, since
+      it was a mere alias.
+
+    o Renamed Connection::real_connect() to connect(), gave
+      several more of its parameters defaults, and removed old
+      connect() function.  Then changed user manual and examples
+      to use new APIs.
+
+    o Replaced Connection::read_option() with new set_option()
+      mechanism.  The name change matches the method's purpose
+      better.  Functional changes are that it returns true on
+      success instead of 0, it supports a broader set of options
+      than read_option() did, and it enforces the correct option
+      argument type.
+
+    o You can now call Connection::set_option() before the
+      connection is established, which will simply queue the option
+      request up until the connection comes up.  If you use this
+      feature, you should use exceptions, because that's the only
+      way an option setting failure can be signalled in this case.
+
+    o Removed query-building functions (exec*(), store*(),
+      use()) from class Connection, and moved all the implementation
+      code to class Query.  Query no longer delegates the final
+      step of sending the query to the database server to
+      Connection().
+
+    o Added Connection::enable_ssl(), for turning on SSL support on
+      a connection.
+
+    o Extracted exception disabling mechanism out of the many
+      classes that had the feature into a new OptionalExceptions
+      base class, which all classes having this feature now
+      derive from.  Also, removed all per-method exception
+      handling flags.  Finally, added NoExceptions class.  With
+      all of these changes, there is now a common way to disable
+      exceptions with fine granularity on all objects that
+      support the feature.
+
+    o All custom MySQL++ exceptions now derive from the new
+      Exceptions class.  This regularizes the exception interface
+      and allows you to use a single catch() block if you want.
+
+    o The "throw exceptions" flag is passed from parent to child
+      in all situations now.  (Or if not, please report it as
+      a bug.) This fulfills a promise made in the v1.7.9 user
+      manual, with the cost being that some programs will see
+      new exceptions thrown that they're not expecting.
+
+    o Added a bunch of new exception types: BadOption,
+      ConnectionFailed, DBSelectionFailed, EndOfResults,
+      EndOfResultSets, LockFailed, and ObjectNotInitialized.
+      Some of these replace the use of BadQuery, which in v1.7.x
+      was a kind of generic exception, thrown when something more
+      specific wasn't available.  Beware, this means that programs
+      may start crashing after recompiling them under v2.0 due to
+      uncaught exceptions, if they were only trying to catch BadQuery.
+
+      There are additional instances where the library will
+      throw new exceptions.  One is when calling a method that
+      forces the internals to use an out-of-bounds index on a
+      vector; previously, this would just make the program
+      likely to crash.  Another is that the library uses the
+      BadFieldName exception -- created in v1.7.30 -- in more
+      apropos situations.
+
+    o Renamed SQLQueryNEParms to BadParamCount, to match naming
+      style of other concrete exception types.
+
+    o Extracted lock()/unlock() functions from Connection and
+      Query classes into a new Lockable interface class.  Locking
+      is implemented in terms of a different class hierarchy, Lock,
+      which allows multiple locking strategies with a single ABI.
+
+    o Removed ResUse::eof().  It's based on a deprecated MySQL
+      C API feature, and it isn't needed anyway.
+
+    o Removed arrow operator (->) for iterator returned by Fields,
+      Result and Row containers.  It was inherently buggy, because
+      a correct arrow operator must return the address of an
+      object, but the underlying element access functions in these
+      classes (e.g. at()) return objects by value, of necessity.
+      Therefore, this operator could only return the address of
+      a temporary, which cannot be safely dereferenced.
+
+    o Returned Row subscripting to something more like the
+      v1.7.9 scheme: there are two operator[] overloads, one for an
+      integer (field by index) and another for const char* (field
+      by name).  lookup_by_name() has been removed.  Because row[0]
+      is ambiguous again, added Row::at() (by analogy with STL
+      sequence containers), which always works.
+
+    o Collapsed two of the Row::value_list*() overloads into
+      two other similar functions using default parameters.
+      This changes the API, but the removed functions aren't
+      used within the library, and I doubt they are used outside,
+      either.
+
+    o Merged RowTemplate into Row.
+
+    o Merged SQLQuery class into Query class.
+
+    o Query is now derived from std::ostream instead of
+      std::stringstream, and we manage our own internal string
+      buffer.
+
+    o Moved SQLParseElement and SQLQueryParms into their own
+      module, qparms.
+
+    o Added multiple result set handling to Query.  MySQL 4.1
+      and higher allow you to give multiple SQL statements in a
+      single "store" call, which requires extensions to MySQL++
+      so you can iterate through the multiple result sets.  Also,
+      stored procedures in MySQL 5.0 reportedly return multiple
+      result sets.  Thanks for the initial patch go to Arnon Jalon;
+      I reworked it quite a bit.
+
+    o Query::storein*() now supports more varieties of the
+      nonstandard slist comtainer.  (Singly-linked version of
+      STL std::list.)
+
+    o Template query mechanism and user manual had several
+      mismatches.  Made manual match actual behavior, or
+      made library match documented behavior, as apropriate.
+      Initial patch by JĆ¼rgen MF Gleiss, with corrections and
+      enhancements by Warren Young.
+
+    o Collapsed mysql_* date and time base classes' methods and
+      data into the subclasses.  Also, DateTime no longer derives
+      from Date and Time; you could get away with that in the
+      old hierarchy, but now it creates an inheritance diamond,
+      and allows unsupported concepts like comparing a Time to
+      a DateTime.
+
+    o Removed "field name" form of Row::field_list().  It was
+      pretty much redundant -- if you have the field names, why
+      do you need a list of field names?
+
+    o ColData can convert itself to bool now.  Thanks for this
+      patch go to Byrial Jensen.
+
+    o Removed simp_list_b type; wasn't being used, and doesn't
+      look to be useful for end-user code.
+
+    o Several methods that used to take objects by value now
+      do so by const reference, for efficiency.
+
+    o Several variable and function renamings so that MySQL++
+      isn't needlessly tied to MySQL.  Even if we never make
+      the library work with other database servers, there's
+      little point in tying this library to MySQL blindly.
+
+    o Renamed all private data members of MySQL++ classes to
+      have trailing underscores.
+
+    o 'private' section follows 'public' section in all classes
+      now.
+
+    o Removed mysql++.hh and sqlplus.hh backwards-compatibility
+      headers.
+
+    o Added copy ctors to Date/Time classes so that they will
+      work in SSQLS under GCC 4.0.0.  Without these, the compiler
+      couldn't make the conversion from raw MySQL row data.
+
+    o Fixed a bunch of GCC 4.0 pedantic warnings: added virtual
+      dtors to all base classes, calling base class ctors from leaf
+      classes, etc.
+
+    o All warnings fixed under VC++ at warning level 3.  (Mostly
+      harmless signedness and integer conversion stuff.)
+
+    o Updated LGPL license/copyright comments at the top of
+      several files to use FSF's new physical address.
+
+    o Relicensed user manual under a close variant of the Linux
+      Documentation Project License, as it's designed for
+      documentation, which the LGPL is not.  Permission for this
+      received from Kevin Atkinson and MySQL AB.
+
+    o Added ABI and API breakages chapter to user manual.  It
+      is basically a subset of this ChangeLog, with only the
+      information an end-user must know when migrating between
+      versions.
+
+    o Reworked user manual's DocBook code quite a bit after
+      reading Bob Stayton's book "DocBook XSL" 3/e.  Better handling
+      of stylesheets, taking advantage of some superior DocBook
+      features, prettier output (especially the HTML version), etc.
+
+    o Rewrote doc/userman/README to make it clearer how to get
+      started contributing to the user manual.  It's essentially a
+      "getting started with DocBook" guide now!
+
+    o Lots of small text improvements to user and reference
+      manuals.  Aside from the obvious tracking of library changes,
+      made a bunch of minor style and clarity improvements.
+
+    o Added CSS stylesheets for userman and refman to
+      make the HTML versions of each a) not ugly; and b) match
+      tangentsoft.net.  (Yes, some may say that these are incompatible
+      goals....)
+
+    o Standardized exception handling code in the examples that
+      use it.
+
+    o Fixed a potential memory leak due to exceptions thrown from
+      ResUse.  Thanks for this patch go to Chris Frey.
+
+    o Using new "no exceptions" feature of library in simple1
+      example, so it is now truly simple.
+
+    o simple1 example no longer depends as much on util module, so
+      that all of the important code is in one place.  Makes
+      learning MySQL++ a little less intimidating.
+
+    o Added new simple2 and usequery examples, to demonstrate
+      the proper way to handle a "use" query, with exceptions
+      disabled, and not, respectively.  Added them to the user
+      manual, in the appropriate place.
+
+    o Refactored the "print stock table" example functions
+      again, to make code using them clearer.
+
+    o UTF-8 to UCS-2 handling in examples is now automatic on
+      Windows.
+
+    o Removed debug code from Windows Unicode output examples
+      that slipped into previous release.
+
+    o resetdb example is now clearer, and more robust in the
+      face of database errors.
+
+    o Simplified connect_to_db() in examples' util module.
+
+    o Added sample autoconf macro for finding MySQL++ libraries, for
+      people to use in their own autotools-based projects.
+
+    o Lots and lots of minor cleanups not worth mentioning
+      individually...
+
+
+1.7.40, 2005.05.26 (r719)
+
+    o Multiple item form of insert() now works if you're using the
+      SQLQuery class, or its derivative, Query.  Thanks to Mark
+      Meredino for this patch.
+
+    o Fixed a bug in const_string::compare(), in which MySQL++
+      would walk off the end of the shorter of the two strings.
+      All was well if the two were the same length.
+
+    o ResUse::operator=() now fully updates the object, so it's more
+      like the behavior of the full ctor.
+
+    o All source files now contain a license and copyright statement
+      somewhere within them.
+
+    o Optimized mysql++.h a bit: it now #includes only the minimum set
+      of files required, and there is now an idempotency guard.
+      This improves compile times a smidge, but mainly it was
+      done to clean up the generated #include file graph in the
+      reference manual.  Before, it was a frightful tangle because
+      we #included everything except custom*.h.
+
+    o Constness fix in MySQL++ date/time classes to avoid compiler
+      warnings with SSQLS.  Thanks to Wolfram Arnold for this patch.
+
+    o Fixed some compiler warnings in custom*.h.  Thanks to Chris Frey
+      for this patch.
+
+    o Added "Submitting Patches" and "Maintaining a Private CVS
+      Repository" sections to the HACKERS file.  Thanks to Chris
+      Frey for the source material for these sections.  The HACKERS
+      file was improved in several other ways at the same time.
+
+    o PDF version of user manual no longer has links to the reference
+      manual.  They were ugly, and they were broken anyway due to the
+      way we move the PDFs after generating them.  If you want
+      interlinked manuals, use the HTML version.
+
+    o PDF version of user manual now has hard page breaks between
+      chapters.
+
+    o Removed complic1 example.  Wasn't pulling its own weight.
+      Everything it is supposed to demonstrate is shown in other
+      examples already.
+
+    o Refactored print_stock_table() in examples/util module to be
+      four functions, and made all the examples use various of
+      these functions where appropriate.  Before, several of
+      the examples had one-off stock table printing code because
+      print_stock_table() wasn't exactly the right thing, for one
+      reason or another.  One practical problem with this is that
+      some of the examples missed out on the recent Unicode updates;
+      now such a change affects all examples the same way.
+
+    o Since so many of the examples rely on the util module, the user
+      manual now covers it.  The simple1 example in the user manual
+      didn't make much sense before, in particular, because it's
+      really just a driver for the util module.
+
+    o Added custom5 example.  It shows how to use the equal_list()
+      functionality of SSQLS.  Thanks to Chris Frey for the original
+      version of this program.  (I simplified it quite a bit after
+      accepting it.)
+
+    o New user manual now covers the value_list(), equal_list() and
+      field_list() stuff that the old manual covered but which was
+      left out in previous versions of the new manaul.  Most of the
+      examples are the same, but the prose is almost completely new.
+      This new section includes the custom5 example.
+
+    o Every declaration in MySQL++ is now documented in the reference
+      manual, or explicitly treated as "internal only".
+
+    o Improved docs for MySQL++'s mechanism to map between MySQL
+      server types and C++ types.  Initial doc patch by Chris Frey,
+      which I greatly reworked.
+
+    o Improved a lot of existing reference manual documentation while
+      adding the new stuff.
+
+    o Expanded greatly on the exception handling discussion in the user
+      manual.
+
+    o Added all-new "Quoting and Escaping" section to the user
+      manual's Tutorial chapter.  Moved some existing comments on
+      quoting and escaping around and added some new ones to other
+      sections as a result.
+
+    o Added all-new "Handling SQL Nulls" section to the user manual's
+      Tutorial chapter.
+
+    o Many improvements to the Overview section of the user manual.
+
+    o Row::operator[] reference now explains the right and wrong way to
+      use the values it returns.  This is in response to a mailing list
+      post where someone was incorrectly using this feature and getting
+      a bunch of dangling pointers.
+
+    o Updated Doxyfile so 1.3.19.1 parses it without warnings.  Still
+      works with versions back to 1.2.18, at least.  (These are
+      the versions shipped with Fedora Core 3 and Red Hat Linux 9,
+      respectively.)
+
+    o Using a superior method to make Doxygen ignore certain sections
+      of the source code.  Between this change and the fact that
+      everything not so ignored is documented, Doxygen no longer
+      generates any warnings.
+
+    o Lots of code style updates.  Everything should now be consistently
+      formatted.
+
+
+1.7.35, 2005.05.05 (r601) The "Cinco de Mayo" release
+
+    o Added a "how to use Unicode with MySQL++" chapter to the user
+      manual.  (Too bad "Cinco de Mayo" doesn't have any accented
+      characters.  That would be just _too_ precious.)
+
+    o VC++ examples now use the Unicode Win32 APIs, so they can display
+      Unicode data from MySQL++.
+
+    o Added an optional conversion function to examples/util.cpp to
+      handle the conversion from UTF-8 to UCS-2 on Win32.
+
+    o Moved "brief history of MySQL++" from intro section of refman to
+      intro section of userman.
+
+    o Lots of small bits of documentation polishing.
+    
+    o Made some minor constness fixes.  Thanks to Erwin van Eijk
+      for this patch.
+
+    o Made some warning fixes for GCC 4.0.  Not all warnings are
+      fixed, because some of the needed changes would break the ABI.
+      Thanks to Chris Frey for this patch.
+
+    o Added lib/Doxyfile to distribution.
+    
+
+1.7.34, 2005.04.30 (r573)
+
+    o Added a multiple-insert method for Query, which lets you insert
+      a range of records from an STL container (or the whole thing,
+      if you like) in a single SQL query.  This is faster, and it
+      reduces coding errors due to less repetition.  Thanks to Mark
+      Meredino for the patch.
+
+    o Reference and user manual now get rebuilt automatically when
+      required.  (E.g. on 'make dist', or explicitly now through 'make
+      docs'.)
+
+    o Made it easier to change the maximum number of SSQLS data members
+      in generated custom-macros.h file.  It used to be hard-coded in
+      several places in lib/custom.pl; now it's a variable at the top of
+      the file.
+
+    o Changed default SSQLS data member limit to 25, which is what it
+      has been documented as for a long time now.  It was actually 26
+      within custom.pl.
+
+    o Fixed a regression in previous version.
+
+    o Trimmed some fat from the distribution packages.
+
+    o Some more small doucmentation improvements.
+
+
+1.7.33, 2005.04.29 (r555)
+
+    o Worked around an overloaded operator lookup bug in VC++ 7.1
+      that caused SSQLS insert, replace and update queries to get
+      mangled.  (Symptom was that custom2 and custom3 examples didn't
+      work right.)  Thanks to Mark Meredino for digging up the
+      following, which explains the problem and gives the solution:
+
+      http://groups-beta.google.com/group/microsoft.public.vc.stl/browse_thread/thread/9a68d84644e64f15
+
+    o Some VC++ warning fixes.
+
+    o Major documentation improvements:
+    
+        o Using DocBook for user manual and Doxygen for reference
+          manual.  The former now references the latter where
+          useful.
+
+        o Split out HACKERS and CREDITS files from main README,
+          and improved remaining bits of README.
+
+        o Moved the text from the old v1.7.9 LaTeX-based
+          documentation over into the new systems, and reworked
+          it to more closely resemble English.
+
+        o Added a lot of new material to documentation, and
+          simplified a lot of what already existed.
+
+        o Documentation is now being built in HTML and PDF forms.
+
+    o ebuild file updated to take advantage of recent configure script
+      features.  Thanks to Chris Frey for this patch.
+
+
+
+1.7.32, 2005.03.10 (r479)
+
+    o Example building may now be skipped with --disable-examples
+      configure script flag.
+
+    o Changed stock items added in resetdb.  One is now UTF-8 encoded,
+      to show that basic use of Unicode with MySQL++ is easy, yet not
+      foolproof.  (See formatting of table on systems where cout isn't
+      UTF-8 aware!)  Other stock items now follow a theme, for your
+      amusement.  :)
+
+    o custom3 example now changes UTF-8 item's name to the 7-bit ASCII
+      equivalent.  Previously, this example would fix a spelling error
+      in the table.
+
+    o resetdb example now says 'why' when it is unable to create the
+      sample database.
+
+    o Small formatting change to print_stock_table(), used by several
+      examples.
+
+    o Was issuing a VC++-specific warning-disable pragma when built by
+      any Windows compiler.  Fixed.
+    
+
+1.7.31, 2005.03.05 (r462) The "Inevitable Point-one Followup" release
+
+    o Check for threads support must now be explicitly requested via
+      configure script's new --enable-thread-check flag.
+
+    o Fix for contacting MySQL server on a nonstandard port number.
+      Thanks to Chris Frey for this patch.
+
+    o Example programs using standard command line format now accept a
+      fourth optional parameter, a port number for the server.  Thanks
+      to Chris Frey for this patch.
+
+    o One more g++ 3.4 pedantic warning fix by Chris Frey.
+
+    o Exception handling in resetdb is no longer nested, because you'd
+      get a segfault on some systems when an exception was thrown from
+      one of the inner try blocks.
+
+    o Improvements to Connection class's handling of locking mechanism.
+      Concept based on patches by Rongjun Mu.
+
+    o Implemented the declared-but-never-defined Query::lock().  Thanks
+      to Rongjun Mu for this patch.
+    
+    o Cleaned up some unclear if/else blocks in connection.cpp by
+      adding explicit braces, correct indenting and putting normal
+      code path in the if side instead of the else.
+
+
+1.7.30, 2005.02.28 (r443) The "Power of Round Numbers" release
+
+    o bootstrap script now accepts a 'pedantic' argument, which sets a
+      bunch of CFLAGS that make g++ very picky about the code it
+      accepts without warnings.
+      
+    o Fixed a bunch of things that generated warnings with g++ in
+      pedantic mode. Only two warnings remain, having to do with
+      floating point comparisons.  (See Wishlist for plans on how to
+      deal with these.)  Thanks to Chris Frey for this patch.
+
+    o Split long tests out of configure.in into M4 files in new config
+      subdir.  This makes configure.in easier to read.
+
+    o Added preliminary thread support.  Currently, this just means that
+      we detect the required compiler and linker thread flags, and link
+      against the proper thread-safe libraries.  THERE MAY BE
+      UN-THREAD-SAFE CODE IN MYSQL++ STILL!
+
+    o Standard C++ exceptions are the default now.  Old pre-Standard
+      exception stuff removed.
+
+    o Row::lookup_by_name() will throw the new BadFieldName exception if
+      you pass a bad field name.  Thanks for this patch to Chris Frey.
+
+    o Row::operator[] will throw a Standard C++ out of bounds exception
+      by way of std::vector::at() if you pass it a bad index.  Thanks
+      for this patch to Chris Frey.
+
+    o Setting Connection::is_connected flag to false on close().
+      Previously, is_connected() would continue to return true after
+      close() was called.
+
+    o All number-to-string conversion ctors in SQLString class now use
+      ostringstream to do the conversion.  Previously, we used
+      snprintf(), which isn't available on all systems.  Also, we used a
+      C99 format specifier for the "long long" conversion, which is also
+      not available on all systems.  This new ostringstream code should
+      be platform-independent, finally.
+
+
+1.7.28, 2005.02.04 (r403)
+
+    o --with-mysql* flags to configure script now try the given
+      directory explicitly, and only if that fails do they try
+      variations, like tacking '/lib' and such onto it to try and find
+      the MySQL includes and libraries.  Thanks to Matthew Walton for
+      the patch.
+
+    o Finally removed sql_quote.h's dependence on custom.h, by moving
+      the one definition it needed from custom.h to deps.h.  This will
+      help portability to compilers that can't handle the SSQLS macros,
+      by making that part of the library truly optional.
+
+
+1.7.27, 2005.01.12 (r395)
+
+    o configure check for libmysqlclient now halts configuration if the
+      library isn't found.  Previously, it would just be flagged as
+      missing, and MySQL++ would fail to build.
+
+    o Added sql_string.cpp to VC++ and BCBuilder project files.
+
+    o Removed Totte Karlsson's 'populate' example, which never made it
+      into the distribution anyway.
+
+    o Removed last vestiges of 'dummy.cpp'.
+
+    o Renamed *.cc to *.cpp in BCBuilder project files.
+
+    o Worked around a BCBuilder C++ syntax processing bug in row.h.
+
+
+1.7.26, 2004.12.17 (r382)
+
+    o Moved all of the SQLString definitions out of the header and into
+      a new .cpp file, reformatted it all, and made the integer
+      conversion functions use snprintf() or _snprintf() instead of
+      sprintf().  Also, widened some of the buffers for 64-bit systems.
+
+    o Using quoted #include form for internal library headers, to avoid
+      some problems with file name clashes.  (The headers should still
+      be installed in their own separate directory for best results,
+      however.)  Thanks to Chris Frey and Evan Wies for the patch and
+      the discussion that lead to it.
+
+    o Removed unnecessary semicolons on namespace block closures.
+      Thanks to Evan Wies for this patch.
+
+    o Fixed namespace handling in the legacy headers mysql++.hh and
+      sqlplus.hh.  Thanks to Chris Frey for this patch.
+
+    o #including iostream instead of ostream in lib/null.h for
+      broader C++ compatibility.  (This may allow MySQL++ to work on GCC
+      2.95.2 again, but this is unconfirmed.)
+
+    o Detecting proper mysql_shutdown() argument handling automatically
+      in platform.h for the Windows compiler case instead of making the
+      user edit the file.  Thanks to Evan Wies for this patch.
+    
+    o Fixed examples/Makefile.simple to use new *.cpp file naming.
+
+    o Fix to Gentoo ebuild file's exception configure switch handling.
+      Thanks to Chris Frey for this patch.
+
+    o Rebuilding lib/custom*.h intelligently now, to avoid unnecessary
+      recompiles after running bootstrap script.
+
+
+1.7.25, 2004.12.09 (r360)
+
+    o Yet more fixes to the --with-mysql-lib and --with-mysql-include
+      flags.
+
+    o Added DLLEXPORT stuff to platform.h, hopefully so that someone
+      can figure out how to make VC++ make a DLL version of MySQL++.
+
+    o Renamed *.cc to *.cpp.
+
+    o Made 'set -> myset' change in VC++ project files.
+
+    o Some style changes (mostly whitespace) in header files.
+
+
+1.7.24, 2004.12.08 (r343)
+
+    o Fixed the --with-mysql-lib and --with-mysql-include flags'
+      behavior, and extended their search ability to handle one other
+      common case.  (Fixed by Steve Roberts)
+
+    o Fixes to put freestanding functions in namespace mysqlpp.  (They
+      weren't in the namespace, while all the class member functions
+      were.)  This required bumping the ABI version number to 4.
+      
+    o Renamed set module to myset, to avoid conflicts with Standard C++
+      Library's set.h when MySQL++ headers were installed into one of
+      the standard system include directories.
+
+    o Renamed all the idempotency guards to make them consistent in
+      style and unique to MySQL++.
+
+    o Reformatted all of lib/*.cc.
+
+
+1.7.23, 2004.11.20 (r333)
+
+    o Query::reset() now empties the stored query string.  If you
+      subsequently stored a longer query in the object, you'd overwrite
+      the previous query, but otherwise the longer part of the previous
+      one would stick out past the new query.
+
+    o We now look to the NO_LONG_LONGS macro only to decide whether to
+      fake 64-bit integer support using 32-bit integers.
+
+    o 64-bit integer support under Visual C++ may be working now, using
+      that platform's __int64_t type.  This has not been tested.
+
+    o Removed 64-bit integer support for Codewarrior on Mac OS 9 and
+      earlier.  OS X uses GCC, so it requires no special support.
+
+    o Added MinGW detection in platform.h.
+    
+    o If you pass a flag (-X) to the examples that take the standard
+      parameters (resetdb, simple1, etc.), it prints a usage message.
+    
+    o Better error handling in resetdb example, where errors are the
+      most critical.  (If that one runs without errors, the others
+      probably will, too, and you have to run that one first.)
+
+    o resetdb now reports success, rather than succeeding silently.
+
+    o Removed the code in sample1 example that duplicated util module's
+      print_stock_table(), and called that function instead.
+
+    o Moved the preview() calls in the example programs to before the
+      query execution calls, because execution modifies the query.
+
+    o All examples that take the standard command line parameters now 
+      exit when connect_to_db() fails in one of the ways that don't
+      throw an exception, rather than bulling onward until the next
+      MySQL database call fails because the connection isn't up.
+
+    o dbinfo example now takes the standard command line parameters.
+
+    o Much better output formatting in dbinfo example.
+
+    o Calling reset() where appropriate in the various example programs.
+      Before, the programs may have worked, but not for the right
+      reason.  This lead some people to believe that calling reset()
+      was not necessary.
+
+    o Fixed an incorrect use of row["string"] in complic1 example.
+
+    o Lots of code style improvements to the examples.
+
+    o Some VC++ type warnings squished.  Some remain.
+    
+
+1.7.22, 2004.11.17 (r302)
+
+    o Applied patches by Zahroof Mohammed to allow it to build under GCC
+      3.4.2.  Tested on MinGW and Fedora Core 3 systems.
+
+    o Removed all the forward declarations in defs.h, and added
+      forward declarations where necessary in individual header files.
+      #including defs.h in fewer locations as a result.
+
+    o Legacy headers sqlplus.hh and mysql++.hh now declare they are
+      using namespace mysqlpp, to allow old code to compile against the
+      new library without changes.
+
+    o Removed query_reset parameter from several class Query member
+      functions.  In the implementation, these parameters were always
+      overridden!  No sense pretending that we pay attention to these
+      parameters.  This changes the ABI version to 3.
+
+    o #including custom.h in sql_query.h again...it's necessary on GCC
+      3.4.
+    
+    o bootstrap script runs lib/config.pl after configure.  This is
+      just a nicety for those running in 'maintainer mode'.
+
+
+1.7.21, 2004.11.05 (r273)
+
+    o Generating a main mysql++ RPM containing just the library files
+      and basic documentation, and the -devel package containing
+      everything else.
+
+    o Devel package contains examples now, along with a new Makefile
+      that uses the system include and library files, rather than the
+      automake-based Makefile.am we currently have which uses the files
+      in the mysql++ source directory.
+
+    o Renamed sqlplusint subdirectory in the package to lib.
+
+    o Removed the obsolete lib/README file.
+
+    o lib/sql_query.h no longer #includes custom.h, simplifying
+      build-time dependencies and shortening compile times.
+
+
+1.7.20, 2004.11.03 (r258)
+
+    o Collapsed all numbered *.hh headers into a single *.h file.  For
+      example, the contents of row1.hh, row2.hh and row3.hh are now in
+      row.h.
+
+    o While doing the previous change, broke several circular
+      dependencies.  (The numbered file scheme was probably partly done
+      to avoid this problem.)  The practical upshot of most of these
+      changes is that some functions are no longer inline.
+
+    o Removed define_short.hh and everything associated with it.  The
+      library now uses the short names exclusively (e.g. Row instead of
+      MysqlRow).
+
+    o Put all definitions into namespace mysqlpp.  For most programs,
+      simply adding a 'using namespace mysqlpp' near the top of the
+      program will suffice to convert to this version.
+
+    o Once again, the main include file was renamed, this time to
+      mysql++.h.  Hopefully this is the last renaming!
+
+    o mysql++.hh still exists.  It emits a compiler warning that the
+      file is obsolete, then it #includes mysql++.h for you.
+
+    o sqlplus.hh is back, being a copy of the new mysql++.hh.  Both of
+      these files may go away at any time.  They exist simply to help
+      people transition to the new file naming scheme.
+
+    o Renamed mysql++-windows.hh to platform.h, and added code to it to
+      handle #inclusion of config.h on autotools-based systems
+      intelligently.  This fixes the config.h error when building under
+      Visual C++.
+
+    o There is now only one place where conditional inclusion of
+      winsock.h happens: platform.h.
+
+    o Beautified the example programs.
+
+
+1.7.19, 2004.10.25 (r186)
+
+    o Fixed an infinite loop in the query mechanism resulting from the
+      strstream change in the previous version.  There is an overloaded
+      set of str() member functions that weren't a problem when query
+      objects were based on strstream.
+     
+    o Query mechanism had a bunch of const-incorrectness: there were
+      several function parameters and functions that were const for
+      the convenience of other parts of the code, but within these
+      functions the constness was const_cast away!  This was evil
+      and wrong; now there are fewer const promises, and only one is
+      still quietly broken within the code.  (It's in the SQLQuery
+      copy ctor implementation; it should be harmless.)
+
+    o Removed operator=() in Query and SQLQuery classes.  It cannot take
+      a const argument for the same reason we have to cast away const
+      in the SQLQuery copy ctor.  It's tolerable to do this in the copy
+      ctor, but intolerable in an operator.  Since the copy ctor is good
+      enough for all code within the library and within my own code, I'm
+      removing the operator.
+
+    o Above changes required bumping the ABI to version 2.
+
+    o Visual C++ projects now look for MySQL build files in c:\mysql,
+      since that's the default install location.  (Previously, it was
+      c:\program files\mysql.)
+
+
+1.7.18, 2004.10.01 (r177)
+
+    o Changed all the strstream (and friends) stuff to stringstream type
+      classes.  Let there be much rejoicing.
+
+    o Query object now lets you use store() even when the SQL query
+      cannot return a result, such as a DROP TABLE command.  This is
+      useful for sending arbitrary SQL to the server.  Thanks to
+      Jose Mortensen for the patch.
+
+    o Quote fix in configure.in, thanks to David Sward.
+
+    o Renamed undef_short file to undef_short.hh.
+
+    o Gentoo ebuild file is actually being shipped with the tarball,
+      instead of just sitting in my private CVS tree since 1.7.14 was
+      current.  Ooops....
+
+
+1.7.17, 2004.09.16 (r170)
+
+    o Reverted one of the VC++ warning fix changes from 1.7.16 that
+      caused crashes on Linux.
+
+    o Added a configure test that conditionally adds the extra 'level'
+      parameter to mysql_shutdown() that was added in MySQL 4.1.3 and
+      5.0.1.
+
+
+1.7.16, 2004.09.13 (r160)
+
+    o Building VC++ version with DLL version of C runtime libraries, and
+      at warning level 3 with no warnings emitted.
+
+    o VC++ build no longer attempts to fake "long long" support.  See
+      the Wishlist for further thoughts on this.
+
+
+1.7.15, 2004.09.02 (r144)
+
+    o Renamed Configure file to common.am, to avoid file name conflict
+      with configure script on case-sensitive file systems.
+
+    o Added ebuild file and ebuild target to top-level Makefile for
+      Gentoo systems.  Thanks to Chris Frey for this.
+
+    o Small efficiency improvements to BadQuery exception handling.
+      Initial idea by Chris Frey, improvements by Warren Young.
+
+
+1.7.14, 2004.08.26 (r130)
+
+    o Builds with Visual C++ 7.1.
+
+    o Fixed a bug in custom macro generation that caused problems with
+      GCC 3.4.  (X_cus_value_list ctor definition was broken.)
+
+
+1.7.13, 2004.08.23 (r92)
+
+    o Removed USL CC support.  (System V stock system compiler.)  Use
+      GCC on these platforms instead.
+
+    o Added examples/README, explaining how to use the examples, and
+      what they all do.
+
+    o Most of the example programs now accept command line arguments for
+      host name, user name and password, like resetdb does.
+
+    o Renamed sinisa_ex example to dbinfo.
+
+    o Several Standard C++ syntax fixes to quash errors emitted by
+      GCC 3.4 and Borland C++ Builder 6.  Thanks to Steffen Schumacher
+      and Totte Karlsson for their testing and help with these.
+
+    o Added proper #includes for BCBuilder, plus project files for same.
+      Thanks to Totte Karlsson for these.
+
+
+1.7.12, 2004.08.19 (r63)
+
+    o Many Standard C++ fixes, most from the GCC 3.4 patch by
+      Rune Kleveland.
+
+    o Added Wishlist file to distribution.
+
+    o Fixed a problem in the bootstrap script that caused complaints
+      from the autotools on some systems.
+
+    o RPM building is working properly now.
+
+    o Fixed the idempotency guard in datetime1.hh.
+
+
+1.7.11, 2004.08.17 (r50)
+
+    o Renamed mysql++, defs and define_short files, adding .hh to the
+      end of each.  (They're header files!)  This shouldn't impact
+      library users, since these are hopefully used internal to the
+      library only.
+
+    o Removed sqlplus.hh file.  Use mysql++.hh instead.
+    
+    o Added mysql++.spec, extracted from contributed 1.7.9 source RPM, 
+      and updated it significantly.  Also, added an 'rpm' target to
+      Makefile.am to automate the process of building RPMs.
+
+    o Added bootstrap and LGPL files to distribution tarball.
+
+    o Added pre-1.7.10 history to this file.
+
+    o Removed .version file.  Apparently it's something required by old
+      versions of libtool.
+
+
+1.7.10, 2004.08.16 (r27)
+
+    o Maintenance taken over by Warren Young (mysqlpp at etr dash usa
+      dot com.) See http://lists.mysql.com/plusplus/3326 for details.
+
+    o Applied many of the GCC 3.x patches submitted for 1.7.9 over
+      the years.  This allows it to build on everything from 3.0 to
+      3.3.3, at least.  Because so many patches are rolled up in one
+      big jump, it's difficult to describe all the changes and where
+      they came from.  Mostly they're Standard C++ fixes, as GCC
+      has become more strict in the source code that it will accept.
+
+    o MysqlRow used to overload operator[] for string types as well as
+      integers so you could look up a field by its name, rather than by
+      its index.  GCC 3.3 says this is illegal C++ due to ambiguities in
+      resolving which overload should be used in various situations.
+      operator[] is now overloaded only for one integer type, and a
+      new member function lookup_by_name() was added to maintain the old
+      by-field-name functionality.
+
+    o Fixed another operator overloading problem in SSQLS macro
+      generation with GCC 3.3.
+
+    o The _table member of SSQLS-defined structures is now const char*,
+      so you can assign to it from a const char* string.
+
+    o Got autoconf/automake build system working with current versions
+      of those tools again.  Removed the generated autotools files from
+      CVS.
+
+    o Renamed library file from libsqlplus to libmysqlpp.
+
+
+1.7.9 (May 1 2001) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * Fixed a serious bug in Connection constructor when reading MySQL
+    * options
+    * Improved copy constructor and some other methods in Result /
+    * ResUse
+    * Many other minor improvements
+    * Produced a complete manual with chapter 5 included
+    * Updated documentation, including a Postscript format
+
+1.7.8 (November 14 2000) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * Introduced a new, standard way of dealing with C++ exceptions.
+    * MySQL++ now supports two different methods of tracing exceptions.
+    * One is by the fixed type (the old one) and one is standard C++
+    * type by the usage of what() method. A choice of methods has to be
+    * done in building a library. If configure script is run with
+    * -enable-exception option , then new method will be used. If no
+    * option is provided, or -disable-exception is used, old MySQL++
+    * exceptions will be enforced. This innovation is a contribution of
+    * Mr. Ben Johnson <ben@blarg.net>
+    * MySQL++ now automatically reads at connection all standard MySQL
+    * configuration files
+    * Fixed a bug in sql_query::parse to enable it to parse more then 99
+    * char's
+    * Added an optional client flag in connect, which will enable usage
+    * of this option, e.g. for getting matched and not just affected
+    * rows. This change does not require any changes in existing
+    * programs
+    * Fixed some smaller bugs
+    * Added better handling of NULL's. Programmers will get a NULL
+    * string in result set and should use is_null() method in ColData to
+    * check if value is NULL
+    * Further improved configuration
+    * Updated documentation, including a Postscript format
+
+1.7.6 (September 22 2000) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * This release contains some C++ coherency improvements and scripts
+    * enhacements
+    * result_id() is made available to programmers to fetch
+    * LAST_INSERT_ID() value
+    * Connection constroctur ambiguity resolved, thanks to marc@mit.edu
+    * Improved cnnfigure for better finding out MySQL libraries and
+    * includes
+    * Updated documentation, including a Postscript format
+
+1.7.5 (July 30 2000) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * This release has mainl bug fixes  and code improvements
+    * A bug in FieldNames::init has been fixed, enabling a bug free
+    * usage of this class with in what ever a mixture of cases that is
+    * required
+    * Changed behaviour of ResUse, Result and Row classes, so that they
+    * could be re-used as much as necessary, without any memory leaks,
+    * nor with any re-initializations necessary
+    * Fixed all potential leaks that could have been caused by usage of
+    * delete instead of delete[] after memory has been allocated with
+    * new[]
+    * Deleted all unused classes and macros. This led to a reduction of
+    * library size to one half of the original size. This has
+    * furthermore brought improvements in compilation speed
+    * Moved all string manipulation from system libraries to
+    * libmysqlclient, thus enabling uniformity of code and usage of 64
+    * bit integers on all platforms, including Windows, without
+    * reverting to conditional compilation. This changes now requires
+    * usage of mysql 3.23 client libraries, as mandatory
+    * Changed examples to reflect above changes
+    * Configuration scripts have been largely changed and further
+    * changes shall appear in consecutive sub-releases. This changes
+    * have been done and shall be done by our MySQL developer Thimble
+    * Smith <tim@mysql.com>
+    * Changed README, TODO and text version of manual. Other versions of
+    * manual have not been updated
+    * Fixed .version ``bug''. This is only partially fixed and version
+    * remains 1.7.0 due to some problems in current versions of libtool.
+    * This shall be finally fixed in a near future
+    * Several smaller fixes and improvements
+    * Added build.sh script to point to the correct procedure of
+    * building of this library. Edit it to add configure options of your
+    * choice
+
+1.7 (May17 2000) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * This is mainly a release dealing with bug fixes, consistency
+    * improvements and easier configure on some platforms
+    * A bug in fetch_row() method of ResUse class has been fixed. Beside
+    * changes that existed in a distributed patch, some additional error
+    * checking has been introduced
+    * A bug in escape manipulator has been fixed that could cause an
+    * error if all characters had to be escaped
+    * An inconsistency in column indexing has been fixed. Before this
+    * version, column names in row indexing with strings, i.e.
+    * row[<string>] , has been case sensitive, which was inconsistent
+    * with MySQL server handling of column names
+    * An inconsistency in conversion from strings to integers or floats
+    * has been fixed. In prior version a space found in data would cause
+    * a BadConversion exception. This has been fixed, but 100%
+    * consistency with MySQL server has not been targeted, so that other
+    * non-numeric characters in data will still cause BadConversion
+    * exception or error. As this API is used in applications, users
+    * should provide feedback if full compatibility with MySQL server is
+    * desired, in which case BadConversion exception or error would be
+    * abolished in some of future versions
+    * A new method in ColData class has been introduced. is_null()
+    * method returns a boolean to denote if a column in a row is NULL.
+    * Finally, as of this release, testing for NULL values is possible.
+    * Those are columns with empty strings for which is_null() returns
+    * true.
+    * Some SPARC Solaris installations had C++ exception problems with
+    * g++ 2.95.2 This was a bug that was fixed in GNU gcc, as from
+    * release 2.95 19990728. This version was thoroughly tested and is
+    * fully functional on SPARC Solaris 2.6 with the above version of
+    * gcc.
+    * A 'virtual destructor ' warning for Result class has been fixed
+    * Several new functions for STL strings have been added. Those
+    * functions (see string_util.hh) add some of the functionality
+    * missing in existing STL libraries
+    * Conversion for 64 bit integers on FreeBSD systems has been added.
+    * On those systems _FIX_FOR_BSD_ should be defined in CXXFLAGS prior
+    * to configuring. Complete conversion to the usage of functions for
+    * integer conversion found in mysqlclient library is planned for one
+    * of the next releases
+    * A completely new, fully dynamic, dramatic and fully mutable result
+    * set has been designed and will be implemented in some of 2.x
+    * releases
+    * Several smaller fixes and improvements, including defaulting
+    * exceptions to true, instead of false, as of this version
+    * An up-to-date and complete Postscript version of documentation is
+    * included in this distribution
+    * Large chunks of this manual are changed, as well as README and
+    * TODO files.
+
+1.6 (Feb 3 2000) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * This is a major release as it includes new features and major
+    * rewrites
+    * Automatic quoting and escaping with streams. It works
+    * automatically , depending on the column type. It will work with <<
+    * on all ostream derived types. it is paricularly handy with query
+    * objects and strstreams. Automatic quoting and escaping on cout,
+    * cerr and clog stream objects is intentionally left out, as quoting
+    * / escaping on those stream objects is not necessary. This feature
+    * can be turned of by setting global boolean dont_quote_auto to
+    * true.
+    * Made some major changes in code, so that now execute method should
+    * be used only with SSQL and template queries, while for all other
+    * query execution of UPDATE's, INSERT's, DELETE's, new method exec()
+    * should be used. It is also faster.
+    * New method get_string is inroduced for easier handling / casting
+    * ColData into C++ strings.
+    * Major rewrite of entire code, which led to it's reduction and
+    * speed improvement. This also led to removal of several source
+    * files.
+    * Handling of binary data is introduced. No application program
+    * changes are required. One of new example programs demonstrates
+    * handling of binary data
+    * Three new example programs have been written and thoroughly
+    * tested. Their intention is to solve some problems addressed by
+    * MySQL users.
+    * Thorough changes is Makefile system has been made
+    * Better configuration scripts are written, thanks to D.Hawkins
+    * <dhawkins@cdrgts.com>
+    * Added several bug fixes
+    * Changed Manual and Changelog
+
+1.5 (Dec 1 1999) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * Fixed bug in template queries, introduced in 1.4 (!)
+    * Fixed connect bug
+    * Fixed several bug in type_info classes
+    * Added additional robustness in classes
+    * Added additional methods for SQL type info
+    * Changed Changelog and README
+
+1.4 (Nov 25 1999) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * Fixed bug in store and storein methods
+    * Fixed one serious memory leak
+    * Fixed a very serious bug generated by gcc 2.95.xx !!
+    * Added robustness in classes, so that e.g. same query and row
+    * objects can be re-used
+    * Changed sinisa_ex example to reflect and demonstrate this
+    * stability
+    * Changed Changelog and README
+    * Few other bug fixes and small improvements and speed-ups
+
+1.3 (Nov 10 1999) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * Fixed several erronous definitions
+    * Further changed source to be 2.95.2 compatible
+    * Expunged unused statements, especially dubious ones, like use of
+    * pointer_tracker
+    * Corrected bug in example file fieldinf1
+    * Finally fixed mysql_init in Connection constructor, which provided
+    * much greater stability !
+    * Added read and get options, so that clients, like mysqlgui can use
+    * it
+    * Changed Changelog and README
+    * Many other bug fixes.
+
+1.2 (Oct 15 1999) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * First offical release. Version 1.0 and 1.1 were releases by Sinisa
+    * before I (Kevin Atkinson) made him the offical maintainer,
+    * Many manual fixes.
+    * Changed README and Changelog
+    * Changed source to be compilable by gcc 2.95.xx, tribute to Kevin
+    * Atkinson <kevinatk@home.com>
+    * Added methods in Connection class which are necessary for
+    * fullfilling administrative functions with MySQL
+    * Added many bug fixes in code pertaining to missing class
+    * initializers , as notified by Michael Rendell <michael@cs.mun.ca>
+    * Sinisa Milivojevic <sinisa@mysql.com> is now the offical
+    * maintainer.
+
+1.1 (Aug 2 1999) Sinisa Milivojevic <sinisa@mysql.com>
+
+    * Added several bug fixes
+    * Fixed memory leak problems and variables overlapping problems.
+    * Added automake and autoconf support by loic@ceic.com
+    * Added Makefile for manual
+    * Added support for cygwin
+    * Added example sinisa_ex (let modesty prevail) which used to crash
+    * a lot when memory allocation, memory leak and overlap problems
+    * were present. Smooth running of this example proves that all those
+    * bugs are fixed
+    * Corrected bugs in sql_query.cc regarding delete versus delete[]
+    * and string length in manip.cc
+    * Changed manual
+    * Changed README
+    * Many other smaller things
+
+1.0 (June 9 1999) Michael Widenius <monty@monty.pp.sci.fi>
+
+    * Added patches from Orion Poplawski <orion@bvt.com> to support the
+    * UnixWare 7.0 compiler
+
+.64.1.1a (Sep 27 1998)
+
+    * Fixed several bugs that caused my library to fail to compile with
+    * egcs 1.1. Hopefully it will still compile with egcs 1.0 however I
+    * have not been able to test it with egcs 1.0.
+    * Removed some problem causing debug output in sql++pretty.
+
+.64.1a (Aug 1 1998)
+
+    * Added an (almost) full guide to using Template Queries.
+    * Fixed it so the SQLQuery will throw an exception when all the
+    * template parameters are not provided.
+    * Proofread and speedchecked the manual (it really needed it).
+    * Other minor document fixes.
+
+.64.0.1a (July 31 1998)
+
+    * Reworked the Class Reference section a bit.
+    * Minor document fixes
+    * Added more examples for SSQLS.
+    * Changed the syntax of equal_list for SSQLS from equal_list (cchar
+    * *, Manip, cchar *) to (cchar *, cchar *, Manip).
+    * Added set methods to SSQLS. These new methods do the same thing as
+    * there corresponding constructors.
+    * Added methods for creating a mysql_type_info from a C++ type_info.
+
+.64.a (July 24 1998)
+
+    * Changed the names of all the classes so they no longer have to
+    * have Mysql in the begging of it. However if this creates a problem
+    * you can define a macro to only use the old names instead.
+    * The Specialized SQL Structures (formally known as Custom Mysql
+    * Structures) changed from mysql_ to sql_.
+    * Added the option of using exceptions thoughout the API.
+    * ColData (formally known as MysqlStrings) will now throw an
+    * exception if there is a problem in the conversion.
+    * Added a null adapter.
+    * Added Mutable Result Sets
+    * Added a very basic runtime type identification for SQL types
+    * Changed the document format from POD to LYX .
+    * Am now using a modified version of Perceps to extract the class
+    * information directly from the code to make my life easier.
+    * Added an option of defining a macro to avoid using the automatic
+    * conversion with binary operators.
+    * Other small fixed I probully forgot to mentune.
+
+.63.1.a
+
+    * Added Custom Mysql Structures.
+    * Fixed the Copy constructor of class Mysql
+    * Started adding code so that class Mysql lets it children now when
+    * it is leaving
+    * Attempted to compile it into a library but still need help. As
+    * default it will compile as a regular program.
+    * Other small fixes.
+
+.62.a (May 3 1998)
+
+    * Added Template Queries
+    * Created s separate SQLQuery object that is independent of an SQL
+    * connection.
+    * You no longer have to import the data for the test program as the
+    * program creates the database and tables it needs.
+    * Many small bug fixes.
+
+.61.1.a (April 28 1998)
+
+    * Cleaned up the example code in test.cc and included it in the
+    * manual.
+    * Added an interface layout plan to the manual.
+    * Added a reverse iterator.
+    * Fixed a bug with row.hh (It wasn't being included because of a
+    * typo).
+
+.61.0.a
+
+    * Major interface changes. I warned you that the interface may
+    * change while it is in pre-alpha state and I wasn't kidding.
+    * Created a new and Separate Query Object. You can no longer execute
+    * queries from the Mysql object instead you have to create a query
+    * object with Mysql::query() and use it to execute queries.
+    * Added the comparison operators to MysqlDate, MysqlTime and
+    * MysqlDateTime. Fixed a few bugs in the MysqlDate... that effected
+    * the stream output and the conversion of them to strings.
+    * Reflected the MysqlDate... changes in the manual.
+    * Added a new MysqlSet object and a bunch of functions for working
+    * with mysql set strings.
+
+.60.3a (April 24 1998)
+
+    * Changed strtoq and strtouq to strtoll and strtull for metter
+    * compatibility Minor Manual fix.
+    * Changed makefile to make it more compatible with Solaris (Thanks
+    * Chris H)
+    * Fixed bug in comparison functions so that they would compare in he
+    * right direction.
+    * Added some items to the to do list be sure to have a look.
+

ADDED   HACKERS.txt
Index: HACKERS.txt
==================================================================
--- /dev/null
+++ HACKERS.txt
@@ -0,0 +1,228 @@
+If you are going to make any changes to MySQL++, this file has some
+hints and commentary you may find helpful.
+
+
+Subversion Access
+~~~~~~~~~~~~~~~~~
+    To check out the current development version from the Gna!
+    Subversion repository, say:
+
+        $ svn co svn://svn.gna.org/svn/mysqlpp/trunk mysqlpp
+
+    If you're a MySQL++ committer, use svn over ssh instead:
+    
+        $ svn co svn+ssh://LOGIN@svn.gna.org/svn/mysqlpp/trunk mysqlpp
+
+    where LOGIN is your Gna! login name.  You will have to have your
+    ssh public key(s) registered with Gna! for this to work.
+
+
+Bootstrapping the Library
+~~~~~~~~~~~~~~~~~~~~~~~~~
+    When you check out MySQL++ from svn, there are a lot of things
+    "missing" as compared to a distributed tarball, because the
+    svn repository contains only source files, no generated files.
+
+    If you're using Windows, there is a simple batch file called
+    bootstrap.bat which wraps up all the steps you need to build
+    these "missing" files.  To run it, just say "bootstrap" from a
+    command shell in the top MySQL++ source directory.  For it to run
+    correctly, you will need Bakefile 0.2.3 (http://bakefile.org/) and
+    a Perl 5 interpreter installed on your system, both in the PATH.
+    The bootstrap script is smart enough to recognize when these
+    tools are missing and stop processing so you can fix the problem.
+
+    For all other platforms, there's a Bourne shell script called
+    bootstrap.  It's quite a bit more complex than the bootstrap.bat
+    file.  It does more, and takes many optional arguments to control
+    its behavior.  All of this is documented in a separate section
+    below.  For many systems, it suffices to just run it without
+    any arguments:
+
+        $ ./bootstrap
+
+    In addition to Bakefile 0.2.3 and Perl 5, you'll also need autoconf
+    1.59 or higher for this to run successfully.
+
+
+Submitting Patches
+~~~~~~~~~~~~~~~~~~
+    If you wish to submit a patch to the library, please send it to
+    the MySQL++ mailing list, or attach it to an entry in our bug
+    tracker on Gna!  We want patches in unified diff format.
+
+    The easiest way to get a unified diff is to check out a copy of
+    the current MySQL++ tree as described in the previous section.
+    Then make your change, cd to the MySQL++ root directory, and ask
+    Subversion to generate the diff for you:
+
+        $ svn diff > mychange.patch
+
+    If your patch adds new files to the distribution, you can say
+    "svn add newfile" before you do the diff, which will include
+    the contents of that file in the patch.  (You can do this even
+    when you've checked out the tree anonymously.)  Then say "svn
+    revert newfile" to make Subversion forget about the new file.
+
+    If you're making a patch against a MySQL++ distribution tarball,
+    then you can generate the diff this way:
+
+        $ diff -ruN mysql++-olddir mysql++-newdir > mychange.patch
+
+    The diff command is part of every Unix and Linux system, and
+    should be installed by default.  If you're on a Windows machine,
+    GNU diff is part of Cygwin (http://cygwin.com/).  Subversion is
+    also available for all of these systems.  There are no excuses
+    for not being able to make unified diffs.  :)
+
+
+Testing Your Proposed Change
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    In v2.3.2, we added a new script called 'dtest'.  You run it
+    like you would most of the examples, except that you don't need
+    to run it via exrun:
+
+        $ ./dtest [password] [user] [server_addr]
+
+    This automatically runs most of the examples, captures the outputs
+    to a file, and then compares that to a known-good run's outputs.
+    The purpose of this is that, before you submit a patch, run dtest
+    and see if it indicates that anything has changed.  If something
+    has and you can't account for it, it represents a problem that
+    you'll have to fix before submitting the patch.
+
+    If your change purposely causes different outputs from the dtest
+    run stored in svn, remove the bmark.txt file, then re-run dtest and
+    include the bmark.txt diffs with your patch.  This communicates
+    to us the fact that you know there are differences and want the
+    patch evaluated anyway.  Otherwise, we are likely to view the
+    change as a bug.
+
+
+Adding Support for a Different Compiler
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MySQL++ uses the Bakefile system for creating project files
+    and makefiles.  This allows us to make changes to a single set
+    of files, and have the proper changes be made to all generated
+    project files and makefiles.  In the past, we used more ad-hoc
+    systems, and we'd frequently forget to update individual project
+    files and makefiles, so at any given time, at least one target
+    was likely to be broken.
+
+    If MySQL++ doesn't currently ship with project files or makefiles
+    tuned for your compiler of choice, you need to work through the
+    Bakefile mechanism to add support.  We're not willing to do ad-hoc
+    platform support any more, so please don't ask if you can send
+    us project files instead; we don't want them.
+
+    If you want to port MySQL++ to another platform, we need to be
+    confident that the entire library works on your platform before
+    we'll accept patches.  In the past, we've had broken ports that
+    were missing important library features, or that crashed when built
+    in certain ways.  Few people will knowingly use a crippled version
+    of MySQL++, since there are usually acceptable alternatives.
+    Therefore, such ports become maintenance baggage with little
+    compensating value.
+
+
+On Manipulating the Build System Source Files
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    If you're using Visual C++, there are two ways to change the Visual
+    Studio project files:
+    
+    - You can just make the changes directly within Visual Studio.  This
+      is a fine way to do it if you're only making small changes for
+      your own purposes.
+
+    - The Visual Studio project files are actually generated from
+      mysql++.bkl by a tool called Bakefile, not maintained directly.
+      (We do it this way because Bakefile can generate many different
+      types of makefiles and project files from this single source file,
+      so all the platforms we support get all the changes at once.)  So,
+      if you want to make changes to the project files and contribute
+      them back to the MySQL++ project, you need to do the changes
+      in mysql++.bkl instead.  Rather than run Bakefile directly to
+      regenerate the project files, we've wrapped up the necessary steps
+      in the rebake.bat batch file.  Any arguments passed to rebake get
+      sent on to Bakefile without change.
+
+    If you're on a Unixy platform, things are a little more complex
+    because the build system uses Autoconf in addition to Bakefile.
+    The source files are mysql++.bkl, configure.ac, and config/*.  If you
+    change any of these, run the bootstrap script to rebuild all their
+    descendant files.
+
+    The bootstrap script also has other functions besides running
+    Bakefile and Autoconf for you:
+
+        $ ./bootstrap [no{doc,ex,lib,opt}] [pedantic] [bat] \
+                      [configure flags]
+
+    Arguments:
+
+    nodoc   The documentation won't be considered a prerequisite for
+            building the distribution tarball.  This is useful on systems
+            where the documentation doesn't build correctly, and you only
+            need to make a binary RPM.  That process requires a tarball,
+            but doesn't need the documentation.  Don't distribute the
+            tarball or SRPM that results, as they are no good for any
+            other purpose.
+
+    noex    The generated Makefiles and project files won't try to build
+            any of the examples.
+
+    nolib   The generated Makefiles and project files won't try to build
+            the MySQL++ library.
+
+    nomaint Turn off "maintainer mode" stuff in the build.  These are
+            features used only by those building MySQL++ from svn.  The
+            'dist' build target uses this when creating the tarball.
+
+    noopt   Compiler optimization will be turned off.  (This currently
+            has no effect on MinGW or Visual C++.)
+
+    pedantic
+            Turns on all of GCC's warnings and portability checks.
+            Good for checking changes before making a public release.
+
+    bat     Asks cmd.exe to run bootstrap.bat for you.  This is useful
+            when using Cygwin just as a command shell in preference
+            to cmd.exe, as opposed to using Cygwin to build MySQL++
+            using its native tools.  Passing 'bat' stops all command
+            line processing in the bootstrap script, so if you
+            also pass some of the other options, make 'bat' last.
+            The only options that affect the built project files and
+            Makefiles work are the no* ones.
+
+    configure options
+            As soon as the bootstrap script sees an option that it
+            doesn't understand, it stops processing the command line.
+            Any subsequent options are passed to the configure script.
+            See README-Unix.txt for more on configure script options.
+
+
+Maintaining a Private CVS Repository
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    You may find it helpful to maintain your own CVS repository.
+    Whenever there is a new MySQL++ release, import it on the vendor
+    branch like this:
+
+        $ cvs import -m "Version 1.7.35" software/mysql++ mysql++ mysql++-1_7_35
+
+    (This assumes that you have your CVSROOT environment variable
+    set properly.)
+
+    Update the HEAD branch like this:
+
+        $ cd mysql++
+        $ cvs update -PdA
+        $ cvs update -j HEAD -j mysql++-1_7_35 -Pd
+        $ cvs ci -m "merged 1.7.35 into HEAD"
+        $ cvs tag mysql++-1_7_35-merged
+
+    Then any changes you make can easily be tracked, and diffs can
+    be produced with rdiff:
+
+        $ cvs rdiff -ru mysql++-1_7_35 -r mysql++-1_7_35_equal_list \
+            $(cat CVS/Repository) > equal_list.patch
+

ADDED   INSTALL.txt
Index: INSTALL.txt
==================================================================
--- /dev/null
+++ INSTALL.txt
@@ -0,0 +1,9 @@
+The installation procedure depends on the compiler you use to build
+MySQL++.  See:
+
+	README-Cygwin.txt     - for Cygwin
+	README-MinGW.txt      - for MinGW
+	README-Unix.txt       - for Unix, Linux, Mac OS X, etc.
+	README-Visual-C++.txt - for Visual C++
+
+Also see the main README.txt file for things that apply to all systems.

DELETED LGPL
Index: LGPL
==================================================================
--- LGPL
+++ /dev/null
@@ -1,481 +0,0 @@
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
-    		    59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the library GPL.  It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    c) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    d) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!

ADDED   LICENSE.txt
Index: LICENSE.txt
==================================================================
--- /dev/null
+++ LICENSE.txt
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+

DELETED Makefile.am
Index: Makefile.am
==================================================================
--- Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-EXTRA_DIST = .version Configure doc devel
-
-SUBDIRS = sqlplusint examples doc

ADDED   Makefile.mingw
Index: Makefile.mingw
==================================================================
--- /dev/null
+++ Makefile.mingw
@@ -0,0 +1,588 @@
+# =========================================================================
+#     This makefile was generated by
+#     Bakefile 0.2.3 (http://www.bakefile.org)
+#     Do not modify, all changes will be overwritten!
+# =========================================================================
+
+
+
+# -------------------------------------------------------------------------
+# These are configurable options:
+# -------------------------------------------------------------------------
+
+# Compiler flags to link shared library 
+LINK_DLL_FLAGS := -shared
+
+# C++ compiler 
+CXX := g++
+
+# Standard flags for C++ 
+CXXFLAGS := 
+
+# Standard preprocessor flags (common for CC and CXX) 
+CPPFLAGS := 
+
+# Standard linker flags 
+LDFLAGS := 
+
+# Type of compiled binaries [debug,release]
+BUILD := debug
+
+
+
+# -------------------------------------------------------------------------
+# Do not modify the rest of this file!
+# -------------------------------------------------------------------------
+
+### Variables: ###
+
+CPPDEPS = -MT$@ -MF$@.d -MD
+MYSQLPP_CXXFLAGS = $(__DEBUGINFO) -mthreads -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -DHAVE_MYSQL_SSL_SET -I"C:\Program Files\MySQL\MySQL Server \
+	5.0\include" $(CPPFLAGS) $(CXXFLAGS)
+MYSQLPP_OBJECTS =  \
+	mysqlpp_beemutex.o \
+	mysqlpp_connection.o \
+	mysqlpp_cpool.o \
+	mysqlpp_datetime.o \
+	mysqlpp_dbdriver.o \
+	mysqlpp_field_names.o \
+	mysqlpp_field_types.o \
+	mysqlpp_manip.o \
+	mysqlpp_myset.o \
+	mysqlpp_mysql++.o \
+	mysqlpp_mystring.o \
+	mysqlpp_null.o \
+	mysqlpp_options.o \
+	mysqlpp_qparms.o \
+	mysqlpp_query.o \
+	mysqlpp_result.o \
+	mysqlpp_row.o \
+	mysqlpp_sql_buffer.o \
+	mysqlpp_stadapter.o \
+	mysqlpp_tcp_connection.o \
+	mysqlpp_transaction.o \
+	mysqlpp_type_info.o \
+	mysqlpp_uds_connection.o \
+	mysqlpp_vallist.o \
+	mysqlpp_wnp_connection.o
+TEST_CPOOL_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_CPOOL_OBJECTS =  \
+	test_cpool_cpool.o
+TEST_DATETIME_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_DATETIME_OBJECTS =  \
+	test_datetime_datetime.o
+TEST_INTTYPES_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_INTTYPES_OBJECTS =  \
+	test_inttypes_inttypes.o
+TEST_MANIP_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_MANIP_OBJECTS =  \
+	test_manip_manip.o
+TEST_NULL_COMPARISON_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE \
+	-D_UNICODE -DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server \
+	5.0\include" $(CPPFLAGS) $(CXXFLAGS)
+TEST_NULL_COMPARISON_OBJECTS =  \
+	test_null_comparison_null_comparison.o
+TEST_QSSQLS_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_QSSQLS_OBJECTS =  \
+	test_qssqls_qssqls.o
+TEST_QSTREAM_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_QSTREAM_OBJECTS =  \
+	test_qstream_qstream.o
+TEST_STRING_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_STRING_OBJECTS =  \
+	test_string_string.o
+TEST_TCP_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_TCP_OBJECTS =  \
+	test_tcp_tcp.o
+TEST_UDS_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_UDS_OBJECTS =  \
+	test_uds_uds.o
+TEST_WNP_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TEST_WNP_OBJECTS =  \
+	test_wnp_wnp.o
+EXCOMMON_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+EXCOMMON_OBJECTS =  \
+	excommon_cmdline.o \
+	excommon_printdata.o
+CGI_JPEG_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+CGI_JPEG_OBJECTS =  \
+	cgi_jpeg_cgi_jpeg.o
+CPOOL_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+CPOOL_OBJECTS =  \
+	cpool_cpool.o
+DBINFO_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+DBINFO_OBJECTS =  \
+	dbinfo_dbinfo.o
+DEADLOCK_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+DEADLOCK_OBJECTS =  \
+	deadlock_deadlock.o
+FIELDINF_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+FIELDINF_OBJECTS =  \
+	fieldinf_fieldinf.o
+FOR_EACH_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+FOR_EACH_OBJECTS =  \
+	for_each_for_each.o
+LOAD_JPEG_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+LOAD_JPEG_OBJECTS =  \
+	load_jpeg_load_jpeg.o
+MULTIQUERY_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+MULTIQUERY_OBJECTS =  \
+	multiquery_multiquery.o
+RESETDB_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+RESETDB_OBJECTS =  \
+	resetdb_resetdb.o
+SIMPLE1_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+SIMPLE1_OBJECTS =  \
+	simple1_simple1.o
+SIMPLE2_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+SIMPLE2_OBJECTS =  \
+	simple2_simple2.o
+SIMPLE3_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+SIMPLE3_OBJECTS =  \
+	simple3_simple3.o
+SSQLS1_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+SSQLS1_OBJECTS =  \
+	ssqls1_ssqls1.o
+SSQLS2_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+SSQLS2_OBJECTS =  \
+	ssqls2_ssqls2.o
+SSQLS3_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+SSQLS3_OBJECTS =  \
+	ssqls3_ssqls3.o
+SSQLS4_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+SSQLS4_OBJECTS =  \
+	ssqls4_ssqls4.o
+SSQLS5_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+SSQLS5_OBJECTS =  \
+	ssqls5_ssqls5.o
+STORE_IF_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+STORE_IF_OBJECTS =  \
+	store_if_store_if.o
+TQUERY1_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TQUERY1_OBJECTS =  \
+	tquery1_tquery1.o
+TQUERY2_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TQUERY2_OBJECTS =  \
+	tquery2_tquery2.o
+TQUERY3_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TQUERY3_OBJECTS =  \
+	tquery3_tquery3.o
+TRANSACTION_CXXFLAGS = -mthreads $(__DEBUGINFO) -Ilib -DUNICODE -D_UNICODE \
+	-DMYSQLPP_NO_DLL -I"C:\Program Files\MySQL\MySQL Server 5.0\include" \
+	$(CPPFLAGS) $(CXXFLAGS)
+TRANSACTION_OBJECTS =  \
+	transaction_transaction.o
+
+### Conditionally set variables: ###
+
+ifeq ($(BUILD),debug)
+__DEBUGINFO = -g
+endif
+ifeq ($(BUILD),release)
+__DEBUGINFO = 
+endif
+
+
+### Targets: ###
+
+all: mysqlpp.dll test_cpool.exe test_datetime.exe test_inttypes.exe test_manip.exe test_null_comparison.exe test_qssqls.exe test_qstream.exe test_string.exe test_tcp.exe test_uds.exe test_wnp.exe libmysqlpp_excommon.a cgi_jpeg.exe cpool.exe dbinfo.exe deadlock.exe fieldinf.exe for_each.exe load_jpeg.exe multiquery.exe resetdb.exe simple1.exe simple2.exe simple3.exe ssqls1.exe ssqls2.exe ssqls3.exe ssqls4.exe ssqls5.exe store_if.exe tquery1.exe tquery2.exe tquery3.exe transaction.exe
+
+clean: 
+	-if exist .\*.o del .\*.o
+	-if exist .\*.d del .\*.d
+	-if exist mysqlpp.dll del mysqlpp.dll
+	-if exist libmysqlpp.a del libmysqlpp.a
+	-if exist test_cpool.exe del test_cpool.exe
+	-if exist test_datetime.exe del test_datetime.exe
+	-if exist test_inttypes.exe del test_inttypes.exe
+	-if exist test_manip.exe del test_manip.exe
+	-if exist test_null_comparison.exe del test_null_comparison.exe
+	-if exist test_qssqls.exe del test_qssqls.exe
+	-if exist test_qstream.exe del test_qstream.exe
+	-if exist test_string.exe del test_string.exe
+	-if exist test_tcp.exe del test_tcp.exe
+	-if exist test_uds.exe del test_uds.exe
+	-if exist test_wnp.exe del test_wnp.exe
+	-if exist libmysqlpp_excommon.a del libmysqlpp_excommon.a
+	-if exist cgi_jpeg.exe del cgi_jpeg.exe
+	-if exist cpool.exe del cpool.exe
+	-if exist dbinfo.exe del dbinfo.exe
+	-if exist deadlock.exe del deadlock.exe
+	-if exist fieldinf.exe del fieldinf.exe
+	-if exist for_each.exe del for_each.exe
+	-if exist load_jpeg.exe del load_jpeg.exe
+	-if exist multiquery.exe del multiquery.exe
+	-if exist resetdb.exe del resetdb.exe
+	-if exist simple1.exe del simple1.exe
+	-if exist simple2.exe del simple2.exe
+	-if exist simple3.exe del simple3.exe
+	-if exist ssqls1.exe del ssqls1.exe
+	-if exist ssqls2.exe del ssqls2.exe
+	-if exist ssqls3.exe del ssqls3.exe
+	-if exist ssqls4.exe del ssqls4.exe
+	-if exist ssqls5.exe del ssqls5.exe
+	-if exist store_if.exe del store_if.exe
+	-if exist tquery1.exe del tquery1.exe
+	-if exist tquery2.exe del tquery2.exe
+	-if exist tquery3.exe del tquery3.exe
+	-if exist transaction.exe del transaction.exe
+
+mysqlpp.dll: $(MYSQLPP_OBJECTS)
+	$(CXX) $(LINK_DLL_FLAGS) -fPIC -o $@ $(MYSQLPP_OBJECTS) $(LDFLAGS) -Wl,--out-implib=libmysqlpp.a $(__DEBUGINFO) -mthreads -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lwsock32 -lmysqlclient
+
+test_cpool.exe: $(TEST_CPOOL_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_CPOOL_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_datetime.exe: $(TEST_DATETIME_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_DATETIME_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_inttypes.exe: $(TEST_INTTYPES_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_INTTYPES_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_manip.exe: $(TEST_MANIP_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_MANIP_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_null_comparison.exe: $(TEST_NULL_COMPARISON_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_NULL_COMPARISON_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_qssqls.exe: $(TEST_QSSQLS_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_QSSQLS_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_qstream.exe: $(TEST_QSTREAM_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_QSTREAM_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_string.exe: $(TEST_STRING_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_STRING_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_tcp.exe: $(TEST_TCP_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_TCP_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_uds.exe: $(TEST_UDS_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_UDS_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+test_wnp.exe: $(TEST_WNP_OBJECTS) mysqlpp.dll
+	$(CXX) -o $@ $(TEST_WNP_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlclient -lmysqlpp
+
+libmysqlpp_excommon.a: $(EXCOMMON_OBJECTS) mysqlpp.dll
+	if exist $@ del $@
+	ar rcu $@ $(EXCOMMON_OBJECTS)
+	ranlib $@
+
+cgi_jpeg.exe: $(CGI_JPEG_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(CGI_JPEG_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+cpool.exe: $(CPOOL_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(CPOOL_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+dbinfo.exe: $(DBINFO_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(DBINFO_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+deadlock.exe: $(DEADLOCK_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(DEADLOCK_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+fieldinf.exe: $(FIELDINF_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(FIELDINF_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+for_each.exe: $(FOR_EACH_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(FOR_EACH_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+load_jpeg.exe: $(LOAD_JPEG_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(LOAD_JPEG_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+multiquery.exe: $(MULTIQUERY_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(MULTIQUERY_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+resetdb.exe: $(RESETDB_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(RESETDB_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+simple1.exe: $(SIMPLE1_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(SIMPLE1_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+simple2.exe: $(SIMPLE2_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(SIMPLE2_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+simple3.exe: $(SIMPLE3_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(SIMPLE3_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+ssqls1.exe: $(SSQLS1_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(SSQLS1_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+ssqls2.exe: $(SSQLS2_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(SSQLS2_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+ssqls3.exe: $(SSQLS3_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(SSQLS3_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+ssqls4.exe: $(SSQLS4_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(SSQLS4_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+ssqls5.exe: $(SSQLS5_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(SSQLS5_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+store_if.exe: $(STORE_IF_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(STORE_IF_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+tquery1.exe: $(TQUERY1_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(TQUERY1_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+tquery2.exe: $(TQUERY2_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(TQUERY2_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+tquery3.exe: $(TQUERY3_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(TQUERY3_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+transaction.exe: $(TRANSACTION_OBJECTS) libmysqlpp_excommon.a mysqlpp.dll
+	$(CXX) -o $@ $(TRANSACTION_OBJECTS) $(LDFLAGS) -mthreads $(__DEBUGINFO) -L. -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc -L"C:\Program Files\MySQL\MySQL Server 5.0\lib\opt"  -lmysqlpp_excommon -lmysqlclient -lmysqlpp
+
+mysqlpp_beemutex.o: ./lib/beemutex.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_connection.o: ./lib/connection.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_cpool.o: ./lib/cpool.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_datetime.o: ./lib/datetime.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_dbdriver.o: ./lib/dbdriver.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_field_names.o: ./lib/field_names.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_field_types.o: ./lib/field_types.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_manip.o: ./lib/manip.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_myset.o: ./lib/myset.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_mysql++.o: ./lib/mysql++.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_mystring.o: ./lib/mystring.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_null.o: ./lib/null.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_options.o: ./lib/options.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_qparms.o: ./lib/qparms.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_query.o: ./lib/query.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_result.o: ./lib/result.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_row.o: ./lib/row.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_sql_buffer.o: ./lib/sql_buffer.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_stadapter.o: ./lib/stadapter.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_tcp_connection.o: ./lib/tcp_connection.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_transaction.o: ./lib/transaction.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_type_info.o: ./lib/type_info.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_uds_connection.o: ./lib/uds_connection.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_vallist.o: ./lib/vallist.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+mysqlpp_wnp_connection.o: ./lib/wnp_connection.cpp
+	$(CXX) -c -o $@ $(MYSQLPP_CXXFLAGS) $(CPPDEPS) $<
+
+test_cpool_cpool.o: ./test/cpool.cpp
+	$(CXX) -c -o $@ $(TEST_CPOOL_CXXFLAGS) $(CPPDEPS) $<
+
+test_datetime_datetime.o: ./test/datetime.cpp
+	$(CXX) -c -o $@ $(TEST_DATETIME_CXXFLAGS) $(CPPDEPS) $<
+
+test_inttypes_inttypes.o: ./test/inttypes.cpp
+	$(CXX) -c -o $@ $(TEST_INTTYPES_CXXFLAGS) $(CPPDEPS) $<
+
+test_manip_manip.o: ./test/manip.cpp
+	$(CXX) -c -o $@ $(TEST_MANIP_CXXFLAGS) $(CPPDEPS) $<
+
+test_null_comparison_null_comparison.o: ./test/null_comparison.cpp
+	$(CXX) -c -o $@ $(TEST_NULL_COMPARISON_CXXFLAGS) $(CPPDEPS) $<
+
+test_qssqls_qssqls.o: ./test/qssqls.cpp
+	$(CXX) -c -o $@ $(TEST_QSSQLS_CXXFLAGS) $(CPPDEPS) $<
+
+test_qstream_qstream.o: ./test/qstream.cpp
+	$(CXX) -c -o $@ $(TEST_QSTREAM_CXXFLAGS) $(CPPDEPS) $<
+
+test_string_string.o: ./test/string.cpp
+	$(CXX) -c -o $@ $(TEST_STRING_CXXFLAGS) $(CPPDEPS) $<
+
+test_tcp_tcp.o: ./test/tcp.cpp
+	$(CXX) -c -o $@ $(TEST_TCP_CXXFLAGS) $(CPPDEPS) $<
+
+test_uds_uds.o: ./test/uds.cpp
+	$(CXX) -c -o $@ $(TEST_UDS_CXXFLAGS) $(CPPDEPS) $<
+
+test_wnp_wnp.o: ./test/wnp.cpp
+	$(CXX) -c -o $@ $(TEST_WNP_CXXFLAGS) $(CPPDEPS) $<
+
+excommon_cmdline.o: ./examples/cmdline.cpp
+	$(CXX) -c -o $@ $(EXCOMMON_CXXFLAGS) $(CPPDEPS) $<
+
+excommon_printdata.o: ./examples/printdata.cpp
+	$(CXX) -c -o $@ $(EXCOMMON_CXXFLAGS) $(CPPDEPS) $<
+
+cgi_jpeg_cgi_jpeg.o: ./examples/cgi_jpeg.cpp
+	$(CXX) -c -o $@ $(CGI_JPEG_CXXFLAGS) $(CPPDEPS) $<
+
+cpool_cpool.o: ./examples/cpool.cpp
+	$(CXX) -c -o $@ $(CPOOL_CXXFLAGS) $(CPPDEPS) $<
+
+dbinfo_dbinfo.o: ./examples/dbinfo.cpp
+	$(CXX) -c -o $@ $(DBINFO_CXXFLAGS) $(CPPDEPS) $<
+
+deadlock_deadlock.o: ./examples/deadlock.cpp
+	$(CXX) -c -o $@ $(DEADLOCK_CXXFLAGS) $(CPPDEPS) $<
+
+fieldinf_fieldinf.o: ./examples/fieldinf.cpp
+	$(CXX) -c -o $@ $(FIELDINF_CXXFLAGS) $(CPPDEPS) $<
+
+for_each_for_each.o: ./examples/for_each.cpp
+	$(CXX) -c -o $@ $(FOR_EACH_CXXFLAGS) $(CPPDEPS) $<
+
+load_jpeg_load_jpeg.o: ./examples/load_jpeg.cpp
+	$(CXX) -c -o $@ $(LOAD_JPEG_CXXFLAGS) $(CPPDEPS) $<
+
+multiquery_multiquery.o: ./examples/multiquery.cpp
+	$(CXX) -c -o $@ $(MULTIQUERY_CXXFLAGS) $(CPPDEPS) $<
+
+resetdb_resetdb.o: ./examples/resetdb.cpp
+	$(CXX) -c -o $@ $(RESETDB_CXXFLAGS) $(CPPDEPS) $<
+
+simple1_simple1.o: ./examples/simple1.cpp
+	$(CXX) -c -o $@ $(SIMPLE1_CXXFLAGS) $(CPPDEPS) $<
+
+simple2_simple2.o: ./examples/simple2.cpp
+	$(CXX) -c -o $@ $(SIMPLE2_CXXFLAGS) $(CPPDEPS) $<
+
+simple3_simple3.o: ./examples/simple3.cpp
+	$(CXX) -c -o $@ $(SIMPLE3_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls1_ssqls1.o: ./examples/ssqls1.cpp
+	$(CXX) -c -o $@ $(SSQLS1_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls2_ssqls2.o: ./examples/ssqls2.cpp
+	$(CXX) -c -o $@ $(SSQLS2_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls3_ssqls3.o: ./examples/ssqls3.cpp
+	$(CXX) -c -o $@ $(SSQLS3_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls4_ssqls4.o: ./examples/ssqls4.cpp
+	$(CXX) -c -o $@ $(SSQLS4_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls5_ssqls5.o: ./examples/ssqls5.cpp
+	$(CXX) -c -o $@ $(SSQLS5_CXXFLAGS) $(CPPDEPS) $<
+
+store_if_store_if.o: ./examples/store_if.cpp
+	$(CXX) -c -o $@ $(STORE_IF_CXXFLAGS) $(CPPDEPS) $<
+
+tquery1_tquery1.o: ./examples/tquery1.cpp
+	$(CXX) -c -o $@ $(TQUERY1_CXXFLAGS) $(CPPDEPS) $<
+
+tquery2_tquery2.o: ./examples/tquery2.cpp
+	$(CXX) -c -o $@ $(TQUERY2_CXXFLAGS) $(CPPDEPS) $<
+
+tquery3_tquery3.o: ./examples/tquery3.cpp
+	$(CXX) -c -o $@ $(TQUERY3_CXXFLAGS) $(CPPDEPS) $<
+
+transaction_transaction.o: ./examples/transaction.cpp
+	$(CXX) -c -o $@ $(TRANSACTION_CXXFLAGS) $(CPPDEPS) $<
+
+.PHONY: all clean
+
+
+SHELL := $(COMSPEC)
+
+# Dependencies tracking:
+-include ./*.d

ADDED   Makefile.simple
Index: Makefile.simple
==================================================================
--- /dev/null
+++ Makefile.simple
@@ -0,0 +1,450 @@
+# =========================================================================
+#     This makefile was generated by
+#     Bakefile 0.2.3 (http://www.bakefile.org)
+#     Do not modify, all changes will be overwritten!
+# =========================================================================
+
+
+
+# -------------------------------------------------------------------------
+# These are configurable options:
+# -------------------------------------------------------------------------
+
+#  
+AR := ar
+
+#  
+RANLIB := ranlib
+
+# C++ compiler 
+CXX := g++
+
+# Standard flags for C++ 
+CXXFLAGS := 
+
+# Standard preprocessor flags (common for CC and CXX) 
+CPPFLAGS := 
+
+# Standard linker flags 
+LDFLAGS := 
+
+# Type of compiled binaries [debug,release]
+BUILD := debug
+
+
+
+# -------------------------------------------------------------------------
+# Do not modify the rest of this file!
+# -------------------------------------------------------------------------
+
+### Variables: ###
+
+CPPDEPS = -MT$@ -MF`echo $@ | sed -e 's,\.o$$,.d,'` -MD
+TEST_CPOOL_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_CPOOL_OBJECTS =  \
+	test_cpool_cpool.o
+TEST_DATETIME_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_DATETIME_OBJECTS =  \
+	test_datetime_datetime.o
+TEST_INTTYPES_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_INTTYPES_OBJECTS =  \
+	test_inttypes_inttypes.o
+TEST_MANIP_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_MANIP_OBJECTS =  \
+	test_manip_manip.o
+TEST_NULL_COMPARISON_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_NULL_COMPARISON_OBJECTS =  \
+	test_null_comparison_null_comparison.o
+TEST_QSSQLS_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_QSSQLS_OBJECTS =  \
+	test_qssqls_qssqls.o
+TEST_QSTREAM_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_QSTREAM_OBJECTS =  \
+	test_qstream_qstream.o
+TEST_STRING_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_STRING_OBJECTS =  \
+	test_string_string.o
+TEST_TCP_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_TCP_OBJECTS =  \
+	test_tcp_tcp.o
+TEST_UDS_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_UDS_OBJECTS =  \
+	test_uds_uds.o
+TEST_WNP_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TEST_WNP_OBJECTS =  \
+	test_wnp_wnp.o
+EXCOMMON_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+EXCOMMON_OBJECTS =  \
+	excommon_cmdline.o \
+	excommon_printdata.o
+CGI_JPEG_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+CGI_JPEG_OBJECTS =  \
+	cgi_jpeg_cgi_jpeg.o
+CPOOL_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+CPOOL_OBJECTS =  \
+	cpool_cpool.o
+DBINFO_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+DBINFO_OBJECTS =  \
+	dbinfo_dbinfo.o
+DEADLOCK_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+DEADLOCK_OBJECTS =  \
+	deadlock_deadlock.o
+FIELDINF_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+FIELDINF_OBJECTS =  \
+	fieldinf_fieldinf.o
+FOR_EACH_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+FOR_EACH_OBJECTS =  \
+	for_each_for_each.o
+LOAD_JPEG_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+LOAD_JPEG_OBJECTS =  \
+	load_jpeg_load_jpeg.o
+MULTIQUERY_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+MULTIQUERY_OBJECTS =  \
+	multiquery_multiquery.o
+RESETDB_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+RESETDB_OBJECTS =  \
+	resetdb_resetdb.o
+SIMPLE1_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+SIMPLE1_OBJECTS =  \
+	simple1_simple1.o
+SIMPLE2_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+SIMPLE2_OBJECTS =  \
+	simple2_simple2.o
+SIMPLE3_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+SIMPLE3_OBJECTS =  \
+	simple3_simple3.o
+SSQLS1_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+SSQLS1_OBJECTS =  \
+	ssqls1_ssqls1.o
+SSQLS2_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+SSQLS2_OBJECTS =  \
+	ssqls2_ssqls2.o
+SSQLS3_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+SSQLS3_OBJECTS =  \
+	ssqls3_ssqls3.o
+SSQLS4_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+SSQLS4_OBJECTS =  \
+	ssqls4_ssqls4.o
+SSQLS5_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+SSQLS5_OBJECTS =  \
+	ssqls5_ssqls5.o
+STORE_IF_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+STORE_IF_OBJECTS =  \
+	store_if_store_if.o
+TQUERY1_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TQUERY1_OBJECTS =  \
+	tquery1_tquery1.o
+TQUERY2_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TQUERY2_OBJECTS =  \
+	tquery2_tquery2.o
+TQUERY3_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TQUERY3_OBJECTS =  \
+	tquery3_tquery3.o
+TRANSACTION_CXXFLAGS = $(__DEBUGINFO) -Ilib -I/usr/include/mysql \
+	-I/usr/include/mysql++ $(CPPFLAGS) $(CXXFLAGS)
+TRANSACTION_OBJECTS =  \
+	transaction_transaction.o
+
+### Conditionally set variables: ###
+
+ifeq ($(BUILD),debug)
+__DEBUGINFO = -g
+endif
+ifeq ($(BUILD),release)
+__DEBUGINFO = 
+endif
+
+
+### Targets: ###
+
+all: test_cpool test_datetime test_inttypes test_manip test_null_comparison test_qssqls test_qstream test_string test_tcp test_uds test_wnp libmysqlpp_excommon.a cgi_jpeg cpool dbinfo deadlock fieldinf for_each load_jpeg multiquery resetdb simple1 simple2 simple3 ssqls1 ssqls2 ssqls3 ssqls4 ssqls5 store_if tquery1 tquery2 tquery3 transaction
+
+install: all
+
+uninstall: 
+
+clean: 
+	rm -f ./*.o
+	rm -f ./*.d
+	rm -f test_cpool
+	rm -f test_datetime
+	rm -f test_inttypes
+	rm -f test_manip
+	rm -f test_null_comparison
+	rm -f test_qssqls
+	rm -f test_qstream
+	rm -f test_string
+	rm -f test_tcp
+	rm -f test_uds
+	rm -f test_wnp
+	rm -f libmysqlpp_excommon.a
+	rm -f cgi_jpeg
+	rm -f cpool
+	rm -f dbinfo
+	rm -f deadlock
+	rm -f fieldinf
+	rm -f for_each
+	rm -f load_jpeg
+	rm -f multiquery
+	rm -f resetdb
+	rm -f simple1
+	rm -f simple2
+	rm -f simple3
+	rm -f ssqls1
+	rm -f ssqls2
+	rm -f ssqls3
+	rm -f ssqls4
+	rm -f ssqls5
+	rm -f store_if
+	rm -f tquery1
+	rm -f tquery2
+	rm -f tquery3
+	rm -f transaction
+
+test_cpool: $(TEST_CPOOL_OBJECTS)
+	$(CXX) -o $@ $(TEST_CPOOL_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_datetime: $(TEST_DATETIME_OBJECTS)
+	$(CXX) -o $@ $(TEST_DATETIME_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_inttypes: $(TEST_INTTYPES_OBJECTS)
+	$(CXX) -o $@ $(TEST_INTTYPES_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_manip: $(TEST_MANIP_OBJECTS)
+	$(CXX) -o $@ $(TEST_MANIP_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_null_comparison: $(TEST_NULL_COMPARISON_OBJECTS)
+	$(CXX) -o $@ $(TEST_NULL_COMPARISON_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_qssqls: $(TEST_QSSQLS_OBJECTS)
+	$(CXX) -o $@ $(TEST_QSSQLS_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_qstream: $(TEST_QSTREAM_OBJECTS)
+	$(CXX) -o $@ $(TEST_QSTREAM_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_string: $(TEST_STRING_OBJECTS)
+	$(CXX) -o $@ $(TEST_STRING_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_tcp: $(TEST_TCP_OBJECTS)
+	$(CXX) -o $@ $(TEST_TCP_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_uds: $(TEST_UDS_OBJECTS)
+	$(CXX) -o $@ $(TEST_UDS_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+test_wnp: $(TEST_WNP_OBJECTS)
+	$(CXX) -o $@ $(TEST_WNP_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp -lmysqlclient
+
+libmysqlpp_excommon.a: $(EXCOMMON_OBJECTS)
+	rm -f $@
+	$(AR) rcu $@ $(EXCOMMON_OBJECTS)
+	$(RANLIB) $@
+
+cgi_jpeg: $(CGI_JPEG_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(CGI_JPEG_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+cpool: $(CPOOL_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(CPOOL_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+dbinfo: $(DBINFO_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(DBINFO_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+deadlock: $(DEADLOCK_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(DEADLOCK_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+fieldinf: $(FIELDINF_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(FIELDINF_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+for_each: $(FOR_EACH_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(FOR_EACH_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+load_jpeg: $(LOAD_JPEG_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(LOAD_JPEG_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+multiquery: $(MULTIQUERY_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(MULTIQUERY_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+resetdb: $(RESETDB_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(RESETDB_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+simple1: $(SIMPLE1_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(SIMPLE1_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+simple2: $(SIMPLE2_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(SIMPLE2_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+simple3: $(SIMPLE3_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(SIMPLE3_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+ssqls1: $(SSQLS1_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(SSQLS1_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+ssqls2: $(SSQLS2_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(SSQLS2_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+ssqls3: $(SSQLS3_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(SSQLS3_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+ssqls4: $(SSQLS4_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(SSQLS4_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+ssqls5: $(SSQLS5_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(SSQLS5_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+store_if: $(STORE_IF_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(STORE_IF_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+tquery1: $(TQUERY1_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(TQUERY1_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+tquery2: $(TQUERY2_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(TQUERY2_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+tquery3: $(TQUERY3_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(TQUERY3_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+transaction: $(TRANSACTION_OBJECTS) libmysqlpp_excommon.a
+	$(CXX) -o $@ $(TRANSACTION_OBJECTS) $(LDFLAGS)  $(__DEBUGINFO) -L.  -lmysqlpp_excommon -lmysqlpp -lmysqlclient
+
+test_cpool_cpool.o: ./test/cpool.cpp
+	$(CXX) -c -o $@ $(TEST_CPOOL_CXXFLAGS) $(CPPDEPS) $<
+
+test_datetime_datetime.o: ./test/datetime.cpp
+	$(CXX) -c -o $@ $(TEST_DATETIME_CXXFLAGS) $(CPPDEPS) $<
+
+test_inttypes_inttypes.o: ./test/inttypes.cpp
+	$(CXX) -c -o $@ $(TEST_INTTYPES_CXXFLAGS) $(CPPDEPS) $<
+
+test_manip_manip.o: ./test/manip.cpp
+	$(CXX) -c -o $@ $(TEST_MANIP_CXXFLAGS) $(CPPDEPS) $<
+
+test_null_comparison_null_comparison.o: ./test/null_comparison.cpp
+	$(CXX) -c -o $@ $(TEST_NULL_COMPARISON_CXXFLAGS) $(CPPDEPS) $<
+
+test_qssqls_qssqls.o: ./test/qssqls.cpp
+	$(CXX) -c -o $@ $(TEST_QSSQLS_CXXFLAGS) $(CPPDEPS) $<
+
+test_qstream_qstream.o: ./test/qstream.cpp
+	$(CXX) -c -o $@ $(TEST_QSTREAM_CXXFLAGS) $(CPPDEPS) $<
+
+test_string_string.o: ./test/string.cpp
+	$(CXX) -c -o $@ $(TEST_STRING_CXXFLAGS) $(CPPDEPS) $<
+
+test_tcp_tcp.o: ./test/tcp.cpp
+	$(CXX) -c -o $@ $(TEST_TCP_CXXFLAGS) $(CPPDEPS) $<
+
+test_uds_uds.o: ./test/uds.cpp
+	$(CXX) -c -o $@ $(TEST_UDS_CXXFLAGS) $(CPPDEPS) $<
+
+test_wnp_wnp.o: ./test/wnp.cpp
+	$(CXX) -c -o $@ $(TEST_WNP_CXXFLAGS) $(CPPDEPS) $<
+
+excommon_cmdline.o: ./examples/cmdline.cpp
+	$(CXX) -c -o $@ $(EXCOMMON_CXXFLAGS) $(CPPDEPS) $<
+
+excommon_printdata.o: ./examples/printdata.cpp
+	$(CXX) -c -o $@ $(EXCOMMON_CXXFLAGS) $(CPPDEPS) $<
+
+cgi_jpeg_cgi_jpeg.o: ./examples/cgi_jpeg.cpp
+	$(CXX) -c -o $@ $(CGI_JPEG_CXXFLAGS) $(CPPDEPS) $<
+
+cpool_cpool.o: ./examples/cpool.cpp
+	$(CXX) -c -o $@ $(CPOOL_CXXFLAGS) $(CPPDEPS) $<
+
+dbinfo_dbinfo.o: ./examples/dbinfo.cpp
+	$(CXX) -c -o $@ $(DBINFO_CXXFLAGS) $(CPPDEPS) $<
+
+deadlock_deadlock.o: ./examples/deadlock.cpp
+	$(CXX) -c -o $@ $(DEADLOCK_CXXFLAGS) $(CPPDEPS) $<
+
+fieldinf_fieldinf.o: ./examples/fieldinf.cpp
+	$(CXX) -c -o $@ $(FIELDINF_CXXFLAGS) $(CPPDEPS) $<
+
+for_each_for_each.o: ./examples/for_each.cpp
+	$(CXX) -c -o $@ $(FOR_EACH_CXXFLAGS) $(CPPDEPS) $<
+
+load_jpeg_load_jpeg.o: ./examples/load_jpeg.cpp
+	$(CXX) -c -o $@ $(LOAD_JPEG_CXXFLAGS) $(CPPDEPS) $<
+
+multiquery_multiquery.o: ./examples/multiquery.cpp
+	$(CXX) -c -o $@ $(MULTIQUERY_CXXFLAGS) $(CPPDEPS) $<
+
+resetdb_resetdb.o: ./examples/resetdb.cpp
+	$(CXX) -c -o $@ $(RESETDB_CXXFLAGS) $(CPPDEPS) $<
+
+simple1_simple1.o: ./examples/simple1.cpp
+	$(CXX) -c -o $@ $(SIMPLE1_CXXFLAGS) $(CPPDEPS) $<
+
+simple2_simple2.o: ./examples/simple2.cpp
+	$(CXX) -c -o $@ $(SIMPLE2_CXXFLAGS) $(CPPDEPS) $<
+
+simple3_simple3.o: ./examples/simple3.cpp
+	$(CXX) -c -o $@ $(SIMPLE3_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls1_ssqls1.o: ./examples/ssqls1.cpp
+	$(CXX) -c -o $@ $(SSQLS1_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls2_ssqls2.o: ./examples/ssqls2.cpp
+	$(CXX) -c -o $@ $(SSQLS2_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls3_ssqls3.o: ./examples/ssqls3.cpp
+	$(CXX) -c -o $@ $(SSQLS3_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls4_ssqls4.o: ./examples/ssqls4.cpp
+	$(CXX) -c -o $@ $(SSQLS4_CXXFLAGS) $(CPPDEPS) $<
+
+ssqls5_ssqls5.o: ./examples/ssqls5.cpp
+	$(CXX) -c -o $@ $(SSQLS5_CXXFLAGS) $(CPPDEPS) $<
+
+store_if_store_if.o: ./examples/store_if.cpp
+	$(CXX) -c -o $@ $(STORE_IF_CXXFLAGS) $(CPPDEPS) $<
+
+tquery1_tquery1.o: ./examples/tquery1.cpp
+	$(CXX) -c -o $@ $(TQUERY1_CXXFLAGS) $(CPPDEPS) $<
+
+tquery2_tquery2.o: ./examples/tquery2.cpp
+	$(CXX) -c -o $@ $(TQUERY2_CXXFLAGS) $(CPPDEPS) $<
+
+tquery3_tquery3.o: ./examples/tquery3.cpp
+	$(CXX) -c -o $@ $(TQUERY3_CXXFLAGS) $(CPPDEPS) $<
+
+transaction_transaction.o: ./examples/transaction.cpp
+	$(CXX) -c -o $@ $(TRANSACTION_CXXFLAGS) $(CPPDEPS) $<
+
+.PHONY: all install uninstall clean
+
+
+# Dependencies tracking:
+-include ./*.d

DELETED README
Index: README
==================================================================
--- README
+++ /dev/null
@@ -1,73 +0,0 @@
-This is C++ API  library for MySQL.
-
-Starting based of 1.2, this is now maintained by sinisa@cytanet.com.cy
-as kevinatk@home.com doesn't have time to support this library anymore. 
-
-He has made sinisa@cytanet.com.cy a new official maintainer, which will
-continue to keep mysql++ library under LGPL.
-
-
-Original information from kevinatk@home.com:
----------------------------------------------------------------------
-
-After several people commented on how my quickie wrapper would be of
-little use I decided to go all out and create a full featured
-version.
-
-To my knowledge this library requiures gcc 2.8 or egcc or better and of
-course the mysql library.
-
-To compile the library and modify the file Configure aproprietly
-and type make.
-
-I am working on trying to get this to compile into a library.
-However I really don't know what I am doing. If you have some
-experense with this please take a look at my makefile and uncomment the
-appropriate lines and let me know if I am doing everything right.
-
-For more information please see the manual.
-
-I developed it using egcc ver 1.02 (I think) from the Debian hamm
-package with kernel 2.0.33 and a Cryix P150+ cpu.  I am also using
-Mysql 3.21.25 that is in the non-free section of the Debian
-distribution.
-
-Be sure to let me know what you think.  I depend on your feedback.
-
-Thanks,
-I can be reached at kevinatk@home.com
---------------------------------------------------------------------
-End of original README by Kevin Atkinson
-
-
-Since October 1999, all maintenance has been transferred to Sinisa
-Milivojevic (sinisa@cytanet.com.cy) and Michael Widenius (monty@mysql.com).
-
-Send your feedback to any of these addresses, or even better to the
-mailing list mysql-plusplus@lists.mysql.com.
-
-Since versin 1.1, mysql++ has been prepared to be built with automake and
-autoconf. 
-
-This will make compilation and  installation much easier. 
-
-You should cd to the root of source directory and run ./configure.
-
-If you are running it several times, because you have problems, do delete 
-config.cache. In case of the problem config.log contains more info on
-it's whereabouts.
-
-After configure is run, config.h and Makefiles are generated. 
-
-If you wish to install mysql++ in a root directory other then /usr/local,
-you should run configure with --with-prefix=.....
-
-Configure contains description of other switches available.
-
-After running configure, run make and make install. Libs will be
-installed in prefix/lib and include files in prefix/include/mysql++.
-
-
-Since version 1.3, mysql++ is fully compliant with latest 2.95.xx series
-of compilers.
-

ADDED   README-Cygwin.txt
Index: README-Cygwin.txt
==================================================================
--- /dev/null
+++ README-Cygwin.txt
@@ -0,0 +1,34 @@
+Prerequisite: Build MySQL
+~~~~~~~~~~~~~~~~~~~~~~~~~
+    Before you can build MySQL++, you need to build the MySQL client
+    library from source.  This is necessary because Cygwin programs
+    work best when linked to Cygwin libraries, even though it's
+    possible to link to some native Windows libraries.  You do not
+    need to build a Cygwin version of the MySQL server; it's still
+    best to use the native Windows version of that.
+
+    The MySQL client library does not build correctly out of the box.
+    The best instructions I've found covering the necessary changes
+    are here:
+
+        http://cygwin.com/ml/cygwin/2004-11/msg00159.html
+
+    I recommend that you use MySQL v4.1.x at this time.  Skip the
+    step changing the pthread stuff in my_thr_init.c, as this change
+    has already been made in recent versions of MySQL.
+
+    With the changes applied, build and install the client library
+    like so:
+
+    $ autoreconf --install --verbose --force
+    $ ./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var \
+        --infodir=/usr/share/info --mandir=/usr/share/man \
+        --disable-shared --without-{debug,readline,libedit,server}
+    $ make
+    $ make install
+
+
+Building the Library and Example Programs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    With that done, you can build MySQL++ just as you would any other
+    typical Unix program.  See README-Unix.txt for details.

ADDED   README-Mac-OS-X.txt
Index: README-Mac-OS-X.txt
==================================================================
--- /dev/null
+++ README-Mac-OS-X.txt
@@ -0,0 +1,76 @@
+OS X is Unix under the hood, so README-Unix.txt covers the generic
+bits.  I'll just cover a few of the issues specific to OS X here.
+
+
+Prerequisite: Install the MySQL Development Files
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MySQL++ is built on top of the MySQL C API library, so for MySQL++
+    to build, it needs at least that library and its header files
+    installed.  You don't need the server itself installed on your
+    development machine, though it's often helpful anyway, for testing.
+    You can get MySQL in at least three different ways for OS X:
+
+    - From Fink: http://finkproject.org/  I mention this first
+      because it's the method I use to test MySQL++ in development.
+      If you ask about OS X on the mailing list, you'll get the most
+      help if you're also using the Fink version of MySQL.  Once you
+      have Fink installed, install the MySQL C API development
+      files with:
+
+      $ fink install mysql15-dev
+      
+      Then, in configuring MySQL++, give the --with-mysql=/sw flag
+      to the configure script.
+    
+    - From MySQL.com.  I've not tried the official binaries,
+      but they're known to work with MySQL++.  As I understand it,
+      they install from a typical Mac GUI installer.  I don't know
+      if it lets you install the development files separately from
+      the server itself, so be sure to check.  The official Windows
+      installers, for instance, have in the past installed the server
+      by default but not the development files.
+
+      Once it's installed, the configure script shipped with MySQL++
+      v3.0 and up should find the library without any help.
+
+    - From MacPorts, http://macports.org.  I have zero information on
+      this other than that it's theoretically possible for it to work.
+      If you figure out how to make it work, please post the method
+      to the mailing list so I can update this document.
+
+
+Making Universal Binaries
+~~~~~~~~~~~~~~~~~~~~~~~~~
+    The command line build system will generate libraries that
+    only work with the platform you build MySQL++ on.  If you need
+    to generate a libmysqlpp that works on both Intel and PowerPC
+    machines, something like this may work:
+
+    $ ./configure CXXFLAGS='-arch ppc -arch i386' --disable-dependency-tracking
+
+    This is untested with MySQL++ in particular, but it's said to work
+    with other projects.
+
+    Note that with Tiger -- and to a greater extent, Leopard --
+    there are really *four* architectures, not two: you have 32-bit
+    and 64-bit versions of both PowerPC and Intel.  I'm not sure
+    exactly how you'd modify the command above to make a library that
+    supports all four, but I'll take a wild guess and say you'll need
+    four -arch flags.  Or, you can just avoid the command line build
+    system, and do it in...
+
+Xcode
+~~~~~
+    Until very recently, there's been no official support in MySQL++
+    for building on OS X using Xcode.  People have gotten it to work
+    before on their own, but it's not something we felt we could
+    support directly.
+
+    As of MySQL++ v3.0, we're including Xcode project files.  So far,
+    they're completely untested, but being part of the official
+    tarball, it obligates us to at least try to support them. :)
+    If they don't work, see HACKERS.txt for more info on fixing
+    the source files that generate these project files.  We're not
+    terribly interested in receiving updated project files.  They can
+    be useful for comparison, but ultimately what we care about is
+    being able to generate them correctly.

ADDED   README-MinGW.txt
Index: README-MinGW.txt
==================================================================
--- /dev/null
+++ README-MinGW.txt
@@ -0,0 +1,103 @@
+Prerequisite: GCC Version
+~~~~~~~~~~~~~~~~~~~~~~~~~
+    If your MinGW version isn't using at least GCC 3.4.5, it needs
+    to be updated.  Older versions are known to not work with MySQL++.
+
+
+Prerequisite: MySQL C Development Files
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MySQL++ is built atop MySQL's C API library, so you need to have
+    MySQL installed on your development system to get the current C API
+    development files.
+
+    If you do a default installation of MySQL, the development files
+    probably won't be installed. As of this writing you have to do
+    either a Complete or Custom install to get these files.  (They keep
+    changing the way the Windows installer works, so this may not be
+    true any more by the time you read this.)
+
+    The MySQL++ Makefile assumes that you installed MySQL in
+    
+        C:\Program Files\MySQL\MySQL Server 5.0\
+    
+    If not, you have two options.
+
+    The simplest is to edit Makefile.mingw.  This is a generated
+    file, but if that's all the only change to MySQL++ you need,
+    it works fine.
+
+    If you're doing deeper work on MySQL++, you should change the
+    variable MYSQL_WIN_DIR at the top of mysql++.bkl instead.  Then to
+    generate Makefile.mingw from that file, you will need the Win32
+    port of Bakefile from http://bakefile.org/  The command to do
+    that is:
+
+        bakefile_gen -f mingw
+
+
+Prerequisite: MySQL C API DLL Import Library
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Before you can build MySQL++ with MinGW, you will need to create
+    a MinGW-compatible import library for MySQL's C API library.
+    Using the current default install path for MySQL and assuming
+    MySQL++ is in c:\mysql++, the commands to do this are:
+
+        cd C:\Program Files\MySQL\MySQL Server 5.0\lib\opt
+        dlltool -k -d c:\mysql++\libmysqlclient.def -l libmysqlclient.a
+
+
+Building the Library and Example Programs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    With the prerequisites above taken care of, you can build MySQL++
+    with this command:
+
+        mingw32-make -f Makefile.mingw
+
+    Notice that we're using the MinGW-specific version of GNU make, not
+    the Cygwin or MSYS versions.  Many things will break otherwise: path
+    separator handling, shell commands used by the Makefile, etc.
+
+    Speaking of Cygwin and MSYS, if you have either these or any other
+    Unix emulation environment installed, be sure their executables
+    aren't in the PATH when building MySQL++.  MinGW's version of GNU
+    make does some funny things if it thinks it's running in the
+    presence of Unixy tools, which will break the MySQL++ build.
+
+    Once the library is built, you should run the examples.  At minimum,
+    run resetdb and simple1.
+
+    Once you're satisfied that the library is working correctly, you can
+    run the install.bat file at the project root to automatically
+    install the library files and headers in subdirectories under
+    c:\mysql++.
+
+
+Cygwin and MinGW Coexistence
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    It's possible to have both Cygwin and MinGW installed and build with
+    the MinGW tools without interference from the Cygwin bits.  The main
+    thing you have to take care of is that MinGW's bin directory must
+    precede the Cygwin bin directory in the PATH, so that its tools are
+    found first.  If you use Cygwin's bash as a command shell in
+    preference to the DOS-like cmd.exe, you can use this shell script to
+    temporarily set the environment to "MinGW mode" and make it easy to
+    get back to "Cygwin mode":
+
+        #!/bin/sh
+        PATH=/c/mingw/bin:/c/windows:/c/windows/system32:/c/cygwin/bin
+        echo "Say 'exit' to leave MinGW shell and restore Cygwin environment."
+        /usr/bin/bash --rcfile ~/.mingwrc
+
+    I recommend having at least this in the ~/.mingwrc file:
+
+        alias make=mingw32-make
+        PS1='MinGW: \W \$ '
+
+    The prompt change reminds you that you are in a sub-shell set up for
+    MinGW.  The alias for 'make' ensures you don't accidentally run
+    Cygwin's make, which won't work with Makefile.mingw.  We could just
+    leave /c/cygwin/bin out of the environment, but there are Cygwin
+    tools we want access to, like vim.  As long as all the MinGW ones
+    override those Cygwin also provides, we don't need to worry about
+    having both in the PATH.  Besides, having the alias is nice for
+    those who have 'make' committed to muscle memory.

ADDED   README-Unix.txt
Index: README-Unix.txt
==================================================================
--- /dev/null
+++ README-Unix.txt
@@ -0,0 +1,70 @@
+Building the Library and Example Programs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MySQL++ uses GNU autoconf, so you can build it with the standard
+    commands:
+
+    $ ./configure
+    $ make
+    $ su
+    # make install
+
+    On Linux, you also need to run 'ldconfig' as root after installing
+    the library.  You may need to add the library's installation
+    directory to /etc/ld.so.conf before you do this, particularly if
+    you installed to /usr/local.
+
+
+Configure Options
+~~~~~~~~~~~~~~~~~
+    The configure script takes several interesting options. Say:
+
+        $ ./configure --help
+
+    to get a list.  Some of the more interesting flags are:
+
+    --prefix:
+
+        If you wish to install mysql++ in a root directory other than
+        /usr/local, run configure with --prefix=/some/dir/name
+
+    --with-mysql*:
+
+        If you installed MySQL in an atypical location, the configure
+        script will not be able to find the library and header
+        files without help.  The simplest way to clue configure into
+        where MySQL is installed is with the --with-mysql option.
+        Try something like "--with-mysql=/usr/local/mysql", for
+        instance.  The configure script will then try to guess which
+        subdirectories under the given directory contain the library
+        and include files.
+
+        If that doesn't work, it's because the library and header
+        files aren't in typical locations under the directory you gave
+        for configure to find them.  So, you need to specify them
+        separately with --with-mysql-include and --with-mysql-lib
+        instead.  As with --with-mysql, configure can often guess
+        which subdirectory under the given directory contains the
+        needed files, so you don't necessarily have to give the full
+        path to these files.
+
+    --enable-thread-check:
+
+        Builds MySQL++ with threading support, if possible.
+        
+        This option simply turns on two tests: first, that your
+        system uses a compatible threading library; and second,
+        that the thread-safe version of the MySQL C API library
+        (libmysqlclient_r) is installed and working.  If both of
+        these are true, you get a thread-aware version of MySQL++.
+        "Thread-aware" means that the library does make an effort to
+        prevent problems, but we don't guarantee that all possible
+        uses of MySQL++ are thread-safe.
+
+        Note that this is a suggestion, not a command.  If we can't
+        figure out the system's threading model or can't find the
+        thread-aware build of the C API library, configure won't fail.
+        It just reverts to the standard single-thread build.
+
+        See the chapter on threading in the user manual for more
+        details and advice on creating thread-safe programs with
+        MySQL++.

ADDED   README-Visual-C++.txt
Index: README-Visual-C++.txt
==================================================================
--- /dev/null
+++ README-Visual-C++.txt
@@ -0,0 +1,218 @@
+Visual C++ Version Compatibility
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MySQL++ is fully-functional with Visual C++ 2005 and 2008.
+
+    MySQL++ also works with VS 2003, with the exception of the SSQLS
+    feature.  There was partial support for SSQLS in the MySQL++
+    v2 series, but a feature we added in MySQL++ v3.0 crashes the
+    compiler, so we had to remove support for it entirely.  You don't
+    need to change anything to use MySQL++ v3 with Visual C++ 2003.
+    The SSQLS parts of the library simply don't get built when you
+    use this compiler.
+
+    Older versions of Visual C++ are basically hopeless when it comes
+    to having sufficient support for Standard C++ to build MySQL++.
+    There is an ancient hacked version of MySQL++ on the official
+    MySQL++ web site that works with Visual C++ 6 and up, but my
+    advice if you're on so old a compiler is that you're better off
+    programming straight to the C API, if only because you can still
+    get support for it.
+
+    There are two sets of .sln and .vcproj files shipped with MySQL++:
+    one for Visual C++ 2003 in the vc2003 subdirectory, and another
+    set for VC++ 2005 and newer in vc2005.  The only difference
+    between them is that the VC++ 2003 versions leave out several
+    things from the build for compatibility reasons.
+
+
+Prerequisites
+~~~~~~~~~~~~~
+    You need to have the Windows version of the MySQL server installed
+    on your development system, even if you always access a MySQL
+    server on a different machine.  This is because in addition to
+    installing the server itself, the official MySQL Windows binaries
+    also install the client-side development files that MySQL++
+    needs in order to communicate with a MySQL server.
+
+    Historically, the Windows version of the MySQL server installer
+    has sometimes installed the development files by default, and
+    sometimes not.  If you get an error about mysql-version.h or
+    mysql.h when building MySQL++, you might need to go back and
+    reinstall the server and select a custom install to enable
+    installation of the development files.
+
+    If you're getting these header file errors and are certain the
+    development files are indeed installed, read on in the following
+    section.
+
+
+Building the Library and Example Programs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    If you installed the MySQL server somewhere other than 
+    
+        C:\Program Files\MySQL\MySQL Server 5.0\
+        
+    you need to change the project file settings.  If you're willing to
+    install Bakefile (see below), you can do this quickly by changing
+    the variable MYSQL_WIN_DIR at the top of the file mysql++.bkl,
+    then regenerating the project files by running rebake.bat.
+    Otherwise, you'll need to change the include and library paths
+    in all of the project files by hand.
+
+    You must build both the Debug and Release versions of the library.
+    You will need them both because when you build your program in
+    Release mode, it won't work with a MySQL++ DLL built in Debug mode.
+    The simplest way to ensure that you're running your program against
+    the correct DLL is to copy the debug version of the MySQL++ DLL
+    into your program's Debug build directory, and the same for the
+    Release directory.
+
+    With the library built, run at least the resetdb and simple1
+    examples to ensure that the library is working correctly.
+    In addition to the other generic examples, there are a few
+    Visual C++ specific examples that you might want to look at in
+    examples\vstudio.  See README-examples.txt for further details.
+
+    Once you're sure the library is working correctly, you can run
+    the install.bat file at the project root to automatically install
+    the library files and headers in subdirectories under c:\mysql++.
+
+
+Using MySQL++ in an MFC Project
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    If you don't already have a project set up, open Visual Studio, say
+    File::New::Project, then choose Visual C++::MFC::MFC Application.
+    Go through the wizard setting up the project as you see fit.
+
+    Once you have your project open, right click on your top-level
+    executable in the Solution Explorer, choose Properties, and make
+    the following changes.  (Where it doesn't specify Debug or Release,
+    make the change to both configurations.)
+
+        o Append the following to C/C++::General::Additional Include
+          Directories:
+
+            C:\Program Files\MySQL\MySQL Server 5.0\include,
+            C:\mysql++\include
+
+        o Under C/C++::Code Generation change "Runtime Library" to
+          "Multi-threaded Debug DLL (/MDd)" for the Debug
+          configuration.  For the Release configuration, make it
+          "Multi-threaded DLL (/MD)".
+
+        o Append the following to Linker::General::Additional Library
+          Directories for the Debug configuration:
+
+            C:\Program Files\MySQL\MySQL Server 5.0\lib\debug,
+            C:\mysql++\vc\debug
+
+          For the Release configuration, make it the same, but
+          change the 'debug' directory names to 'opt'.
+
+        o Under Linker::Input add the following to "Additional
+          Dependencies" for the Debug configuration:
+          
+            libmysql.lib wsock32.lib mysqlpp_d.lib
+
+          ...and then for the Release configuration:
+          
+            libmysql.lib wsock32.lib mysqlpp.lib
+
+          This difference is because MySQL++'s Debug DLL and import
+          library have a _d suffix so you can have both installed
+          without conflicts.
+
+    You may want to study examples\vstudio\mfc\mfc.vcproj to see
+    this in action.  Note that some of the paths will be different,
+    because it can use relative paths for mysqlpp.dll.
+
+
+Using MySQL++ in a Windows Forms C++/CLI Project
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Before you start work on getting MySQL++ working with your own
+    program, you need to make some changes to the MySQL++ build
+    settings.  Open mysqlpp.sln, then right-click on the mysqlpp
+    target and select Properties.  Make the following changes for
+    both the Debug and Release configurations:
+
+        o Under Configuration Properties::General, change "Common
+          Language Runtime support" to the /clr setting.
+
+        o Under C/C++::Command Line, remove the /EHsc from the
+          Additional Options section.
+
+    If you have already built MySQL++, be sure to perform a complete
+    rebuild after changing these options.  The compiler will emit
+    several C4835 warnings after making those changes, which are
+    harmless when using the DLL with a C++/CLI program, but which warn
+    of real problems when using it with unmanaged C++.  As a result,
+    it's probably best if you don't install the resulting DLL in a
+    system level directory.  I'd recommend copying it only into the
+    same directory as the EXE.
+
+    Once you have MySQL++ built with CLR support, open your
+    program's project.  If you don't already have a project set up,
+    open Visual Studio, say File::New::Project, then choose Visual
+    C++::CLR::Windows Forms Application.  Go through the wizard
+    setting up the project as you see fit.
+
+    The configuration process isn't much different from that for an
+    MFC project, so go through the list above first.  Then, make the
+    following changes particular to .NET and C++/CLI:
+
+        o Under Configuration Properties::General change the setting
+          from /clr:pure to /clr.  (You need mixed assembly support
+          to allow a C++/CLI program to use a plain C++ library
+          like MySQL++.)
+
+        o For the Linker::Input settings, you don't need wsock32.lib.
+          The mere fact that you're using .NET takes care of that
+          dependency for you.
+
+    In the MFC instructions above, it said that you need to build it
+    using the Multi-threaded DLL version of the C++ Runtime Library.
+    That's not strictly true for MFC, but it's an absolute requirement
+    for C++/CLI.  See the Remarks in this MSDN article for details:
+
+        http://msdn2.microsoft.com/en-us/library/k8d11d4s.aspx
+
+    You may want to study examples\vstudio\wforms\wforms.vcproj to
+    see all this in action.  Note that some of the paths will be
+    different, because it can use relative paths for mysqlpp_d.dll
+    and mysqlpp.dll.
+
+
+Working With Bakefile
+~~~~~~~~~~~~~~~~~~~~~
+    MySQL++'s Visual Studio project files aren't maintained directly.
+    Instead, we use a tool called Bakefile (http://bakefile.org/)
+    to generate many different project file and Makefile types from a
+    single set of source files.  There is a native Windows version of
+    Bakefile up on that web site.  Download that and put the directory
+    containing bakefile.exe in your Windows PATH.
+
+    Bakefile generates the various project files and Makefiles from
+    a single source file, mysql++.bkl.  This is usually the file you
+    need to change when you want to submit some change to the MySQL++
+    build system.
+
+    While Bakefile's documentation isn't as comprehensive as it
+    ought to be, you can at least count on it to list all of the
+    available features.  So, if you can't see a way to make Bakefile
+    do something, it's likely it just can't do it.  Bakefile is a
+    high-level abstraction of build systems in general, so it'll never
+    support all the particulars of every odd build system out there.
+
+    Once you've made your changes, you can generate the Visual C++
+    project files by running rebake.bat, which you can find in the
+    same directory as this README file.
+
+
+If You Run Into Problems...
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Especially if you have linking problems, make sure your project
+    settings match the above.  Visual C++ is very picky about things
+    like run time library settings.  When in doubt, try running one
+    of the example programs.  If it works, the problem is likely in
+    your project settings, not in MySQL++.
+

ADDED   README-examples.txt
Index: README-examples.txt
==================================================================
--- /dev/null
+++ README-examples.txt
@@ -0,0 +1,185 @@
+Building the Examples
+~~~~~~~~~~~~~~~~~~~~~
+    If you're installing MySQL++ from the source tarball, the example
+    programs get built when you build the library.  If you change
+    any example code, just say 'make' to rebuild the examples.
+    The examples are built against the headers and library in the
+    lib subdirectory, not against the ones you may have installed
+    elsewhere on the system.
+
+    If these example files were installed on your system as part of
+    the -devel RPM, copy all the files to a directory you can write
+    to, then say 'make' in that directory.  This uses a simplified
+    Makefile, which builds the examples against the headers and
+    libraries installed in the system directories.
+
+
+Getting Started with the Examples
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MySQL++ is built as a shared library on most systems, and a DLL
+    on Windows.  Since it isn't built in the same directory as the
+    examples, this means that your system won't be able to find the
+    library without help until you install it.  Since you generally
+    want to run the examples _before_ installing the library, to test
+    that the library actually works, we need a workaround.
+
+    That workaround is the exrun script.  There are two versions,
+    a Bourne shell script called just exrun for POSIX systems, and
+    exrun.bat for Windows.
+
+    Before running the other examples, you must first create the
+    sample database.  On POSIX systems, you do that like so:
+
+        $ ./exrun resetdb [-s server_addr] [-u user] [-p password]
+
+    On Windows, that would instead be:
+
+        C:\mysql++\> exrun.bat resetdb [-s server] [-u user] [-p pass]
+
+    You don't have to give any of these options.  If you don't pass -s,
+    it assumes the database server is running on the same machine,
+    and so tries to contact the server over some form of local IPC.
+    If you don't pass -u, it uses your own user name when logging
+    into to the database server.  If you don't pass -p, it assumes the
+    database user has an empty password, which hopefully is not true.
+
+    The -s option accepts many different forms of address.  The main
+    one is some sort of TCP/IP address, with an optional port number
+    or service name.  On Unixy systems, you can give a Unix domain
+    socket name.  On Windows, you can give just a period to use named
+    pipes, if the server supports it.  All of these are legal:
+
+        .
+        localhost
+        172.20.0.252:12345
+        /var/run/mysqld.sock
+        my.server.name.com:mysql
+
+    If you give -s but don't give a port number or service name with
+    it, it assumes the default, port 3306.
+
+
+Running the Other Command Line Examples
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    The following examples use the database set up by resetdb, and
+    have the same command line format as resetdb:
+
+        simple1: Shows the item names for all records in the sample
+            stock table.  Try this one if you do nothing else.
+
+        simple2: Similar to simple1, but it displays all columns
+            from the sample stock table, not just the item name.
+
+        simple3: Same as simple2, except that it retrieves the data
+            with a "use" query instead of a "store" query.  See the
+            user manual for the difference between these methods.
+
+        ssqls1-5: These demonstrate the SSQLS features.  Read the
+            SSQLS sections in the user manual for details about
+            these examples.
+
+        multiquery: MySQL++ allows you to issue multiple queries at
+            once, and get the results as separate sets.  This shows
+            that, and also how to use stored procedures, which return
+            their results in the same way as a multiquery.
+
+        tquery1-3: Shows how to use the template query facility.
+
+        transaction: Shows how to use the Transaction class to create
+            transaction sets which automatically roll back if not
+            explicitly committed.
+
+        deadlock: Shows how to handle errors that happen when the
+            database server detects a deadlock in a transaction set.
+            Also demonstrates the need for BadQuery::errnum()
+
+        store_if: Demonstrates the Query::store_if() method, which
+            allows you to store the results of a query in an STL
+            container conditionally.  Think of it as a way to express
+            rules for selecting records in C++, to be used when SQL's
+            WHERE clause isn't powerful enough.
+
+        for_each: Demonstrates the Query::for_each() method, which
+            allows you to execute a query and call a functor on each
+            returned row.  This example uses this to gather statistics
+            on the sample table's contents.
+
+        cpoolp, cpoolw: Respectively, the POSIX and Windows threads
+            variants of the ConnectionPool class demonstration.
+
+        load_jpeg: Inserts a JPEG file into the sample database,
+            for use by the cgi_jpeg example.  (See below.)  Unlike the
+            other examples, this one takes anything given on the
+            command line that isn't a switch to be a JPEG file name.
+            We've included examples/logo.jpg as a sample, if you want
+            to use that.
+
+        fieldinf: Shows how to get information about the fields in
+            a result set.  (Types, etc.)
+
+        dbinfo: Dumps a bunch of information about the database
+            server and some of the data it's managing.
+
+    If you run the load_jpeg example, you should consider also
+    playing with the other half of the demonstration, cgi_jpeg.
+    To run it, you'll need to install MySQL++ on a machine with
+    a web server, then copy the cgi_jpeg program to the server's
+    CGI directory.  For example, on a stock Red Hat type box,
+    that would be /var/www/cgi-bin.  At that point, a request like
+    http://my.server.com/cgi-bin/cgi_jpeg?id=1 should show the JPEG you
+    loaded.  The ID value to use will be that reported by load_jpeg.
+
+
+Dedicated Windows Examples
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+    If you're a Visual C++ user, there are two examples specially
+    created for you:
+
+        examples\vstudio\mfc.vcproj: A GUI replacement for the simple2
+            example, it simply logs in and displays the stock table's
+            contents.  Uses good old C++ and MFC.
+
+        examples\vstudio\wforms.vcproj: The same thing, only written in
+            C++/CLI and using Windows Forms.  We needed a second
+            example for two reasons.  First, string handling is quite
+            different under .NET than in unmanaged C++.  Second, many
+            developers are now using Visual Studio Express, which
+            doesn't include MFC.  Please read README-Visual-C++.txt
+            before trying to run this example.  The MySQL++ build
+            settings must be modified before it will run correctly.
+
+    Before trying to run these examples, run the updexdll.bat file
+    in the top MySQL++ directory.  This copies the built mysqlpp.dll
+    files into the Windows examples' EXE output directories so you
+    can run them before you're ready to formally install the DLL on
+    your system.
+
+    Open examples\vstudio\mysqlpp_gui_examples.sln to begin working
+    with these examples.  They only work correctly in Visual Studio
+    2005 right now.  If you want to backport them to VS 2003, it's
+    probably not hard, and we will accept patches for this.  The main
+    difficulty is that VS 2003 supports Managed C++, which isn't the
+    same thing as C++/CLI.
+
+    The main justification for these examples is that Unicode is
+    handled differently in Windows GUI programs than on the POSIX
+    systems where MySQL++ was born and raised.  In earlier versions
+    of MySQL++, the command line examples had very limited Unicode
+    support on Windows, but it was unrealistic and confusing.  Now the
+    command line examples don't even try to handle Unicode on Windows,
+    leaving that up to these new GUI examples.
+
+
+Special exrun Capabilities
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+    The Bourne shell version of the exrun script has a few features
+    not avaiable in the Windows batch file version.  These features
+    let you run the examples under various debugging tools.
+
+    You can get simple gdb debugging if you run an example like this:
+
+        $ ./exrun gdb simple1 foo bar qux
+
+    The script also supports valgrind, in memory leak testing mode:
+
+        $ ./exrun valgrind simple1 foo bar qux

ADDED   README.txt
Index: README.txt
==================================================================
--- /dev/null
+++ README.txt
@@ -0,0 +1,125 @@
+What It Is
+~~~~~~~~~~
+    MySQL++ is a C++ wrapper for MySQL's C API.  It is built around STL
+    principles, to make dealing with the database as easy as dealing
+    with an STL container.  MySQL++ relieves the programmer of dealing
+    with cumbersome C data structures, generation of repetitive SQL
+    statements, and manual creation of C++ data structures to mirror
+    the database schema.
+
+    Its home page is http://tangentsoft.net/mysql++/
+
+
+Prerequisites
+~~~~~~~~~~~~~
+    To build MySQL++, you must have the MySQL C API development
+    files installed.
+
+    On Unixy systems (Linux, Mac OS X, Cygwin, "real" Unix...),
+    the MySQL development files are installed if you build MySQL
+    from source.  If you installed MySQL as a binary package, then
+    the development files are often packaged separately from the
+    MySQL server itself.  It's common for the package containing the
+    development files to be called something like "MySQL-devel".
+
+    If you're building on Windows with Visual C++ or MinGW, you
+    need to install the native Win32 port of MySQL from mysql.com.
+    The development files are only included with the "complete"
+    version of the MySQL installer, and some versions of this
+    installer won't actually install them unless you do a custom
+    install.  Another pitfall is that MySQL++'s project files assume
+    that you've installed the current General Availability release of
+    MySQL (v5.0 right now) and it's installed in the default location.
+    If you've installed a different version, or if MySQL Inc. changes
+    the default location (which they seem to do regularly!) you'll have
+    to adjust the link and include file paths in the project settings.
+
+
+Additional Things to Read
+~~~~~~~~~~~~~~~~~~~~~~~~~
+    Each major platform we support has a dedicated README-*.txt
+    file for it containing information specific to that platform.
+    Please read it.
+
+    For authorship information, see the CREDITS.txt file.
+
+    For license information, see the COPYING.txt file.
+
+    If you want to change MySQL++, see the HACKERS.txt file.
+
+    You should have received a user manual and a reference manual
+    with MySQL++.  If not, you can read a recent version online:
+
+        http://tangentsoft.net/mysql++/doc/
+
+    Search the MySQL++ mailing list archives if you have more
+    questions:
+
+        http://lists.mysql.com/plusplus/
+
+
+Building the Library
+~~~~~~~~~~~~~~~~~~~~
+    MySQL++ uses Bakefile (http://bakefile.org/) to generate
+    platform-specific project files and makefiles from a single set
+    of input files.  We currently support these platforms:
+
+    autoconf:
+        For Unixy platforms, including Linux, Mac OS X, and Cygwin. See
+        README-Unix.txt for details.  Supplementary details for Cygwin
+        are in README-Cygwin.txt, and for OS X in README-Mac-OS-X.txt.
+
+    MinGW:
+        We ship Makefile.mingw for MinGW.  It currently only builds the
+        static version of the library for technical reasons.  This has
+        licensing ramifications.  See README-MinGW.txt for details.
+
+    Visual C++:
+        We ship Visual C++ 2003 project files.  This is the oldest
+        version MySQL++ will run on, due to compiler limitations.
+        See README-Visual-C++.txt for more details.
+
+    Xcode:
+        We ship an Xcode v2 project file.  It hasn't been tested
+        much yet, since the autoconf method works just fine on OS X.
+        As a result, we need both success and failure reports on the
+        mailing list.  See README-Mac-OS-X.txt for more information.
+
+
+Example Programs
+~~~~~~~~~~~~~~~~
+    You may want to try out the programs in the examples subdirectory
+    to ensure that the MySQL++ API and your MySQL database are both
+    working properly.  Also, these examples give many examples of
+    the proper use of MySQL++.  See README-examples.txt for further
+    details.
+
+
+Unsupported Compliers
+~~~~~~~~~~~~~~~~~~~~~
+    If you're on Windows but want to use some other compiler besides
+    Visual C++ or GCC, you are currently on your own.  There have
+    been past efforts to port MySQL++ to other Windows compilers,
+    but for one reason or another, all of these ports have died.
+
+    On Unixy systems, GCC still works best.  "Native" compilers and
+    third-party compilers may work, but you're on your own to get
+    it working.
+
+    We have nothing in particular against these unsupported systems.
+    We just lack the time and resources to support everything
+    ourselves.  If you are sufficiently motivated to get MySQL++
+    working on one of these alternate systems, see the HACKERS.txt
+    file first for guidance.  If you follow the advice in that file,
+    your patch will be more likely to be accepted.
+
+
+If You Want to Hack on MySQL++...
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    If you intend to change the library or example code, please read
+    the HACKERS.txt file.
+
+    If you want to change the user manual, read doc/userman/README.txt
+
+    If you want to change the reference manual, see the Doxygen manual:
+    http://www.stack.nl/~dimitri/doxygen/manual.html

ADDED   Wishlist
Index: Wishlist
==================================================================
--- /dev/null
+++ Wishlist
@@ -0,0 +1,147 @@
+Patches for any of these thoughtfully considered!  See the HACKERS.txt
+file for instructions on sending patches.
+
+
+Any Version
+-----------
+    o Any time you must hand-roll some SQL code in your program,
+      consider whether it could be generalized to a widely-useful
+      API feature.
+
+
+v3.1 Tentative Plan
+-------------------
+    o SSQLS v2:
+
+      - Switch from C macros to a DSL that is translated to .cpp and
+        .h files by a tool built along with MySQL++ library.  Design:
+
+        http://lists.mysql.com/plusplus/6929
+
+      - Switch per SSQLS that makes it throw an exception when it sees
+        a mismatch between DB schema and SSQLS definition.  Harkens
+        back to pre v3.0 SSQLS behavior, where you'd get a crash as
+        it tried to fill out fields by position, and fail.  For the
+        B&D folk who don't like the new "just cope" behavior.
+
+      - Try to design it so as much code as possible resides in
+        a common base class (SsqlsBase) that all SSQLSes derive from.
+        Can't do it in v1 because virtually everything is specific
+        to the structure's type.  Study equal_list(), for example.
+        Do it with an eye toward replacing Query's template methods
+        taking SSQLSes with concrete methods taking SsqlsBase&.
+
+      - Add truthiness operator to SSQLS to detect an incompletely-
+        populated object?  Or maybe an incomplete() method?
+
+      - Add features to ssqlsxlat to write SSQLSv2 declaration files
+        from existing schemas extracted from CREATE TABLE statements,
+        from running databases, and from C++ files containing old
+        SSQLS v1 declarations.
+
+      - Add table creation ability to SSQLS.  It has the schema...
+
+      - Support per-instance table name overrides, instead of just
+        per SSQLS?  Needed if you're going to use a single SSQLS for
+        many tables with the same structure in a multithreaded program,
+        so changing it statically isn't safe.
+
+      - Need a way to tag a column as auto-increment so it's left out
+        of INSERT queries, but still available for data retrieval.
+
+    o Chris Frey's packarray class
+
+    o Create adaptors for std::bitset, for storing binary data in a
+      MySQL table.  Make two options available, one for storing the
+      return from bitset::to_ulong() in an UNSIGNED INTEGER column,
+      and another for storing a larger set of bits in a more flexible
+      way, perhaps as a BLOB.
+
+    o field_list should use backticks to quote its items to handle
+      spaces and other special characters.  Probably also remove all
+      the manipulator stuff associated with these: no reason to make
+      it user-settable, as there's only one right way to do it.  See:
+
+         http://dev.mysql.com/doc/refman/5.0/en/identifiers.html
+
+    o Add a general-purpose backtick manipulator as well.
+
+    o Define operator<< for Fields, Row, StoreQueryResult, etc.  In other
+      words, there should be a way to get a user-readable version of
+      received data without a lot of code.  CSV format by default, and
+      mysql(1)-like ASCII grid optionally, perhaps with a manipulator?
+      There is grid code in examples/multiquery.cpp which we can use
+      and then make multiquery.cpp a demonstration platform for it.
+      Maybe dbinfo and fieldinf, too?
+
+    o Has experience with new thread awareness changed our mind on
+      atomic inc/dec of reference counts in RefCounted*?
+
+    o Create a fixed-point data type for use with SQL's DECIMAL and
+      related types.  Right now, sql_decimal is a typedef for double,
+      so you lose accuracy in the fractional part.
+
+    o Optional checked conversions in String for numerics: throw
+      BadConversion on range overflow?
+
+
+v4.0 or Later
+-------------
+    o Database independence:
+
+      - Make DBDriver class purely abstract; move its entire functional
+        contents to new MysqlDriver.
+
+      - Must create at least two other DBDriver subclasses to
+        ensure base class is reusable before releasing v4.0.
+        PostgresDriver and SqlLiteDriver?
+
+      - Templatize all classes that use DBDriver interface with the
+        DB driver type.  This lets you specify the driver type to use
+        with a Connection and all its children without modifying the
+        existing method parameter lists.  This also lets us worry less
+        about C API types, as they can be hidden away behind typedefs:
+
+        class MysqlDriver : public DBDriver { ...
+           typedef MYSQL_ROW row_type;
+           ...
+        }
+
+        template <class DBD = MysqlDriver>
+        class Connection ... { ...
+           Query<DBD> query();
+           ...
+        }
+
+        template <class DBD = MysqlDriver>
+        class UseQueryResult { ...
+            DBD::row_type fetch_raw_row();
+        }
+
+      - Tricky bits:
+    
+        - Initializing result set objects.
+
+        - type_info module.  Extremely closely tied to MySQL C API
+          right now.  Will probably have to turn it into a parallel
+          class hierarchy to DBDriver, or fold it in with same.
+
+        - Building MySQL++ on systems without autoconf.  How to
+          specify what DB engines are available?  Probably default to
+          supporting MySQL only, and let people turn things on manually
+          as they need them.  Or, maybe make them use Bakefile so they
+          can fiddle with the options if they want something atypical.
+
+    o Some sort of support for prepared statements.  Can we hijack
+      the template query mechanism?
+
+    o If SSQLSv2 does use a common base class, change Query template
+      methods taking SSQLS into concrete methods taking SsqlsBase&.
+
+    o Make Query::insert(), replace() and update() execute their
+      queries immediately.  Requires an ABI break, because they'll
+      have to return SimpleResult.
+
+	o Switch Query's safe bool to overload basic_ios<>::operator
+	  void*() instead.  We create an ambiguous conversion in bool
+	  context with some C++ standard libraries otherwise.

ADDED   bk-deps
Index: bk-deps
==================================================================
--- /dev/null
+++ bk-deps
@@ -0,0 +1,105 @@
+#!/bin/sh
+
+# This script is part of Bakefile (http://www.bakefile.org) autoconf
+# script. It is used to track C/C++ files dependencies in portable way.
+#
+# Permission is given to use this file in any way.
+
+DEPSMODE=gcc
+DEPSDIR=.deps
+DEPSFLAG="-MMD"
+
+mkdir -p $DEPSDIR
+
+if test $DEPSMODE = gcc ; then
+    $* ${DEPSFLAG}
+    status=$?
+
+    # determine location of created files:
+    while test $# -gt 0; do
+        case "$1" in
+            -o )
+                shift
+                objfile=$1
+            ;;
+            -* )
+            ;;
+            * )
+                srcfile=$1
+            ;;
+        esac
+        shift
+    done
+    depfile=`basename $srcfile | sed -e 's/\..*$/.d/g'`
+    depobjname=`echo $depfile |sed -e 's/\.d/.o/g'`
+
+    # if the compiler failed, we're done:
+    if test ${status} != 0 ; then
+        rm -f $depfile
+        exit ${status}
+    fi
+
+    # move created file to the location we want it in:
+    if test -f $depfile ; then
+        sed -e "s,$depobjname:,$objfile:,g" $depfile >${DEPSDIR}/${objfile}.d
+        rm -f $depfile
+    else
+        # "g++ -MMD -o fooobj.o foosrc.cpp" produces fooobj.d
+        depfile=`basename $objfile | sed -e 's/\..*$/.d/g'`
+        if test ! -f $depfile ; then
+            # "cxx -MD -o fooobj.o foosrc.cpp" creates fooobj.o.d (Compaq C++)
+            depfile="$objfile.d"
+        fi
+        if test -f $depfile ; then
+            sed -e "/^$objfile/!s,$depobjname:,$objfile:,g" $depfile >${DEPSDIR}/${objfile}.d
+            rm -f $depfile
+        fi
+    fi
+    exit 0
+elif test $DEPSMODE = mwcc ; then
+    $* || exit $?
+    # Run mwcc again with -MM and redirect into the dep file we want
+    # NOTE: We can't use shift here because we need $* to be valid
+    prevarg=
+    for arg in $* ; do
+        if test "$prevarg" = "-o"; then
+            objfile=$arg
+        else
+            case "$arg" in
+                -* )
+                ;;
+                * )
+                    srcfile=$arg
+                ;;
+            esac
+        fi
+        prevarg="$arg"
+    done
+    $* $DEPSFLAG >${DEPSDIR}/${objfile}.d
+    exit 0
+elif test $DEPSMODE = unixcc; then
+    $* || exit $?
+    # Run compiler again with deps flag and redirect into the dep file.
+    # It doesn't work if the '-o FILE' option is used, but without it the
+    # dependency file will contain the wrong name for the object. So it is
+    # removed from the command line, and the dep file is fixed with sed.
+    cmd=""
+    while test $# -gt 0; do
+        case "$1" in
+            -o )
+                shift
+                objfile=$1
+            ;;
+            * )
+                eval arg$#=\$1
+                cmd="$cmd \$arg$#"
+            ;;
+        esac
+        shift
+    done
+    eval "$cmd $DEPSFLAG" | sed "s|.*:|$objfile:|" >${DEPSDIR}/${objfile}.d
+    exit 0
+else
+    $*
+    exit $?
+fi

ADDED   bmark.txt
Index: bmark.txt
==================================================================
--- /dev/null
+++ bmark.txt
@@ -0,0 +1,183 @@
+All unit tests passed
+---------------- BEGIN resetdb OUTPUT ----------------
+Connecting to database server...
+Dropping existing sample data tables...
+Creating stock table...
+Populating stock table...inserted 4 rows.
+Creating empty images table...
+Creating deadlock testing tables...
+Reinitialized sample database successfully.
+================ END resetdb OUTPUT ================
+
+---------------- BEGIN simple1 OUTPUT ----------------
+We have:
+	NĆ¼rnberger Brats
+	Pickle Relish
+	Hot Mustard
+	Hotdog Buns
+================ END simple1 OUTPUT ================
+
+---------------- BEGIN simple2 OUTPUT ----------------
+Item                           Num       Weight    Price     Date
+
+NĆ¼rnberger Brats              97        1.5       8.79      2005-03-10
+Pickle Relish                  87        1.5       1.75      1998-09-04
+Hot Mustard                    73        0.95      0.97      1998-05-25
+Hotdog Buns                    65        1.1       1.10      1998-04-23
+================ END simple2 OUTPUT ================
+
+---------------- BEGIN simple3 OUTPUT ----------------
+Item                           Num       Weight    Price     Date
+
+NĆ¼rnberger Brats              97        1.5       8.79      2005-03-10
+Pickle Relish                  87        1.5       1.75      1998-09-04
+Hot Mustard                    73        0.95      0.97      1998-05-25
+Hotdog Buns                    65        1.1       1.10      1998-04-23
+================ END simple3 OUTPUT ================
+
+---------------- BEGIN store_if OUTPUT ----------------
+Records found: 2
+
+Item                           Num       Weight    Price     Date
+
+NĆ¼rnberger Brats              97        1.5       8.79      2005-03-10
+Hot Mustard                    73        0.95      0.97      1998-05-25
+================ END store_if OUTPUT ================
+
+---------------- BEGIN for_each OUTPUT ----------------
+There are 322 items weighing 416.85 stone and costing 1147.19 cowrie shells.
+================ END for_each OUTPUT ================
+
+---------------- BEGIN multiquery OUTPUT ----------------
+Multi-query: 
+DROP TABLE IF EXISTS test_table; CREATE TABLE test_table(id INT); INSERT INTO test_table VALUES(10); UPDATE test_table SET id=20 WHERE id=10; SELECT * FROM test_table; DROP TABLE test_table
+Result set 0 is empty.
+Result set 1 is empty.
+Result set 2 is empty.
+Result set 3 is empty.
+Result set 4 has 1 row:
+  +----+
+  | id |
+  +----+
+  | 20 |
+  +----+
+Result set 5 is empty.
+Stored procedure query: 
+DROP PROCEDURE IF EXISTS get_stock; CREATE PROCEDURE get_stock( i_item varchar(20) ) BEGIN SET i_item = concat('%', i_item, '%'); SELECT * FROM stock WHERE lower(item) like lower(i_item); END;
+Result set 0 is empty.
+Result set 1 is empty.
+Query: CALL get_stock('relish')
+Result set 0 has 1 row:
+  +---------------+-----+--------+-------+------------+-------------+
+  |          item | num | weight | price |      sdate | description |
+  +---------------+-----+--------+-------+------------+-------------+
+  | Pickle Relish |  87 |    1.5 |  1.75 | 1998-09-04 |        NULL |
+  +---------------+-----+--------+-------+------------+-------------+
+Result set 1 is empty.
+================ END multiquery OUTPUT ================
+
+---------------- BEGIN tquery1 OUTPUT ----------------
+Query: select * from stock
+Records found: 4
+
+Item                           Num       Weight    Price     Date
+
+Nuerenberger Bratwurst         97        1.5       8.79      2005-03-10
+Pickle Relish                  87        1.5       1.75      1998-09-04
+Hot Mustard                    73        0.95      0.97      1998-05-25
+Hotdog Buns                    65        1.1       1.1       1998-04-23
+================ END tquery1 OUTPUT ================
+
+---------------- BEGIN resetdb OUTPUT ----------------
+Connecting to database server...
+Dropping existing sample data tables...
+Creating stock table...
+Populating stock table...inserted 4 rows.
+Creating empty images table...
+Creating deadlock testing tables...
+Reinitialized sample database successfully.
+================ END resetdb OUTPUT ================
+
+---------------- BEGIN tquery2 OUTPUT ----------------
+Query: select * from stock
+Records found: 4
+
+Item                           Num       Weight    Price     Date
+
+Nuerenberger Bratwurst         97        1.5       8.79      2005-03-10
+Pickle Relish                  87        1.5       1.75      1998-09-04
+Hot Mustard                    73        0.95      0.97      1998-05-25
+Hotdog Buns                    65        1.1       1.1       1998-04-23
+================ END tquery2 OUTPUT ================
+
+---------------- BEGIN tquery3 OUTPUT ----------------
+Stuff we have a lot of in stock:
+	Nuerenberger Bratwurst
+	Pickle Relish
+================ END tquery3 OUTPUT ================
+
+---------------- BEGIN resetdb OUTPUT ----------------
+Connecting to database server...
+Dropping existing sample data tables...
+Creating stock table...
+Populating stock table...inserted 4 rows.
+Creating empty images table...
+Creating deadlock testing tables...
+Reinitialized sample database successfully.
+================ END resetdb OUTPUT ================
+
+---------------- BEGIN ssqls1 OUTPUT ----------------
+We have:
+	NĆ¼rnberger Brats
+	Pickle Relish
+	Hot Mustard (good American yellow mustard, not that European stuff)
+	Hotdog Buns
+================ END ssqls1 OUTPUT ================
+
+---------------- BEGIN ssqls2 OUTPUT ----------------
+Query: INSERT INTO stock (item,num,weight,price,sdate,description) VALUES ('Hot Dogs',100,1.5,1.75,'1998-09-25',NULL)
+Query: select * from stock
+Records found: 5
+
+Item                           Num       Weight    Price     Date
+
+NĆ¼rnberger Brats              97        1.5       8.79      2005-03-10
+Pickle Relish                  87        1.5       1.75      1998-09-04
+Hot Mustard                    73        0.95      0.97      1998-05-25
+Hotdog Buns                    65        1.1       1.1       1998-04-23
+Hot Dogs                       100       1.5       1.75      1998-09-25
+================ END ssqls2 OUTPUT ================
+
+---------------- BEGIN ssqls3 OUTPUT ----------------
+Query: UPDATE stock SET item = 'Nuerenberger Bratwurst',num = 97,weight = 1.5,price = 8.7899999999999991,sdate = '2005-03-10',description = NULL WHERE item = 'NĆ¼rnberger Brats'
+Query: select * from stock
+Records found: 5
+
+Item                           Num       Weight    Price     Date
+
+Nuerenberger Bratwurst         97        1.5       8.79      2005-03-10
+Pickle Relish                  87        1.5       1.75      1998-09-04
+Hot Mustard                    73        0.95      0.97      1998-05-25
+Hotdog Buns                    65        1.1       1.1       1998-04-23
+Hot Dogs                       100       1.5       1.75      1998-09-25
+================ END ssqls3 OUTPUT ================
+
+---------------- BEGIN ssqls4 OUTPUT ----------------
+Records found: 5
+
+Item                           Num       Weight    Price     Date
+
+Hot Dogs                       100       1.5       1.75      1998-09-25
+Hot Mustard                    73        0.95      0.97      1998-05-25
+Hotdog Buns                    65        1.1       1.1       1998-04-23
+Nuerenberger Bratwurst         97        1.5       8.79      2005-03-10
+Pickle Relish                  87        1.5       1.75      1998-09-04
+
+Currently 65 hotdog buns in stock.
+================ END ssqls4 OUTPUT ================
+
+---------------- BEGIN ssqls5 OUTPUT ----------------
+Custom query:
+select * from stock where weight = 1.5 and price = 8.7899999999999991
+================ END ssqls5 OUTPUT ================
+

ADDED   bootstrap
Index: bootstrap
==================================================================
--- /dev/null
+++ bootstrap
@@ -0,0 +1,105 @@
+#!/bin/sh
+
+ARGS=1
+BF_OPTIONS=
+MAINT_FLAGS="--cache-file=config.cache --enable-maintainer-mode"
+while [ $ARGS != 0 ]
+do
+	case "$1" in
+		bat)
+			cmd /c bootstrap.bat $BF_OPTIONS
+			exit 0
+			;;
+
+		nodoc)
+			BF_OPTIONS="-DBUILDDOCS=no $BF_OPTIONS"
+			shift
+			;;
+
+		noex)
+			BF_OPTIONS="-DBUILDEXAMPLES=no $BF_OPTIONS"
+			shift
+			;;
+
+		nolib)
+			BF_OPTIONS="-DBUILDLIBRARY=no $BF_OPTIONS"
+			shift
+			;;
+
+		nomaint)
+			MAINT_FLAGS=
+			shift
+			;;
+
+		noopt)
+			export CXXFLAGS="-g -O0"
+			shift
+			;;
+
+		pedantic)
+			export CXXFLAGS="-g -O2 -ansi -pedantic -Wall -W -Wold-style-cast -Wfloat-equal -Wwrite-strings -Wno-overloaded-virtual -Wno-long-long -Wno-variadic-macros -D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC"
+			shift
+			;;
+
+		*)
+			ARGS=0
+			;;
+	esac
+done
+
+rm -f config.cache
+
+# Do Bakefile stuff first
+set -x &&
+	mkdir -p vc2003 vc2005 &&
+	bakefilize &&
+	bakefile_gen $BF_OPTIONS &&
+	bakefile -f gnu -o Makefile.simple -DBUILDLIBRARY=no mysql++.bkl &&
+	set +x &&
+	success=shonuff
+
+# Get rid of INSTALL symlink added by bakefilize.  We already have
+# INSTALL.txt.
+rm -f INSTALL
+
+# If that succeeded, move on to autotools stuff, etc.
+set +x
+if [ -n "$success" ]
+then
+	mv autoconf_inc.m4 config > /dev/null 2>&1	# don't care if it fails
+
+	# Find location of Bakefile's stock M4 autoconf macros
+	for d in /usr /usr/local
+	do
+		BAKEFILE_M4=$d/share/aclocal
+		if [ -e $BAKEFILE_M4/bakefile.m4 ] ; then break ; fi
+	done
+	if [ ! -e $BAKEFILE_M4/bakefile.m4 ]
+	then
+		echo
+		echo "Failed to find bakefile.m4.  Add the directory containing"
+		echo "this to the bootstrap script."
+		echo
+		exit 1
+	fi
+
+	success=
+	set -x &&
+		aclocal -I config -I $BAKEFILE_M4 &&
+		autoheader &&
+		autoconf &&
+		./configure $MAINT_FLAGS $* &&
+		make lib/querydef.h lib/ssqls.h &&
+		set +x &&
+		success=awyeah
+fi
+
+# Detect failure in any part of above
+if [ -z "$success" ]
+then
+	echo
+    echo BOOTSTRAP FAILED!
+    echo
+    exit 1
+fi
+

ADDED   bootstrap.bat
Index: bootstrap.bat
==================================================================
--- /dev/null
+++ bootstrap.bat
@@ -0,0 +1,60 @@
+@echo off
+if not exist vc2003 mkdir vc2003
+if not exist vc2005 mkdir vc2005
+
+bakefile_gen %*
+if errorlevel 1 exit
+if not exist mysql++.sln goto no_bakefile
+
+cd lib
+perl querydef.pl
+if errorlevel 1 exit
+if not exist querydef.h goto no_perl
+perl ssqls.pl
+if errorlevel 1 exit
+if not exist ssqls.h goto no_perl
+
+if not exist mysql++.h goto no_mysqlpp_h
+cd ..
+
+exit
+
+:no_bakefile
+echo.
+echo Bakefile doesn't seem to be installed on this system.  Download it
+echo from http://bakefile.org/  You need version 0.2.3 or newer.
+echo.
+exit
+
+:no_perl
+echo.
+echo You need a Perl interpreter installed on your system, somewhere in
+echo the PATH.  Any recent version or flavor should work; we don't use
+echo any special extensions.  The easiest to install on Windows would be
+echo ActivePerl, from http://activestate.com/Products/activeperl/
+echo If you're familiar with Unix, you might like Cygwin better instead:
+echo http://cygwin.com/setup.exe
+echo.
+cd ..
+exit
+
+:no_mysqlpp_h
+echo.
+echo WARNING: Can't make lib/mysql++.h
+echo.
+echo On Unixy systems, autoconf creates lib/mysql++.h from lib/mysql++.h.in
+echo but there is no easy way to do this on Windows.  You can do it manually:
+echo just copy the file to the new name, and edit the MYSQLPP_HEADER_VERSION
+echo definition to put the proper version number parts into the macro.  It
+echo needs to look something like this:
+echo.
+echo #define MYSQLPP_HEADER_VERSION MYSQLPP_VERSION(3, 0, 0)
+echo.
+echo It's important that the three numbers match the actual library version
+echo number, or else programs that check this (like resetdb) will fail.
+echo.
+echo Alternately, if you've also got MySQL++ installed on some Unixy type
+echo system, you can let its bootstrap procedure create mysql++.h and then
+echo copy it to the Windows machine.
+echo.
+cd ..

ADDED   cleanmf
Index: cleanmf
==================================================================
--- /dev/null
+++ cleanmf
@@ -0,0 +1,3 @@
+#!/bin/sh
+rm -f Makefile*
+rm -rf *.xcodeproj vc200?

DELETED config.cygwin
Index: config.cygwin
==================================================================
--- config.cygwin
+++ /dev/null
@@ -1,104 +0,0 @@
-####### Compiler, tools and options
-
-CC	=	g++
-CFLAGS	= -DWINDOZE -D_WIN32 -O0 -mno-cygwin -D__cplusplus	-Wall
--fstrength-reduce -D__WIN32__ -I/cygnus/cygwin-b20/include/g++ -I/cygnus/cygwin-b20/include/g++ -I/my/mysql_src/mysql-3.22.13-beta/include -L/my/mysql_src/mysql-3.22.13-beta/client/.libs -L../sqlplusint  -mno-cygwin
-#CFLAGS +=	-fkeep-inline-functions
-# If you have problems when with undefined refrences try uncommenting
-# the above line when compiling the library.  But then recommenting 
-# it when you compile the examples.  
-FPIC    =#	-fPIC
-INCPATH	=	 -I/cygnus/cygwin-b20/include/g++ -I/my/mysql_src/mysql-3.22.13-beta/include # make sure you can find mysql.h
-LINK	=	g++
-LFLAGS  = -mno-cygwin			# make sure you can find mysqlclinet
-NLFLAGS =       -lmysql++       # this is for the static lib test
-SLFLAGS	=	-lmysql++       # this is for shared lib test
-LIBS	=	-lmysqlclient -mno-cygwin
-SOLLIBS = 	-lnsl -lsocket	# extra lib that Solaris needs 
-ARC	=	ar rc
-CP_R    =       cp -a
-RMDIR   =	echo
-#RMDIR   =	rmdir 
-#uncomment the above line if your sure your rmdir does NOT delete non-empty
-#directories.  If it does make remove could be DISASTORIUS.
-INSTLIB  =	/usr/lib
-INSTHEAD =	/usr/include
-INSTBIN  =      /usr/bin
-PERLPATH =      /usr/bin/perl
-
-#CFLAGS  +=	-D NO_LONG_LONGS
-
-#TYPE    =	objs
-TYPE	 =	static
-#TYPE	=	shared
-
-TARGET  =	linux
-#TARGET	= 	solaris
-##
-
-# You should not need to modify anything below this line. If you do
-# need to modify something below this line please email me at
-# sinisa@cytanet.com.cy with what you did.
-
-ifeq ($(TARGET), solaris)
-  LIBS += $(SOLLIBS)
-endif
-
-OBJSINT = coldata.o connection.o datetime.o field_names.o field_types.o \
-  manip.o query.o result.o row.o set.o sql_query.o type_info.o vallist.o
-
-HEADERS = mysql++ mysql++.h mysql++-custom mysql++-custom.h
-
-HEADSINT = mysql++ defs \
- define_short coldata1.hh \
- type_info1.hh const_string1.hh \
- null1.hh compare1.hh row1.hh \
- resiter1.hh vallist1.hh manip1.hh \
- sql_string1.hh sql_query1.hh \
- sql_query0.hh datetime1.hh \
- stream2string1.hh tiny_int1.hh \
- set1.hh connection1.hh query1.hh \
- result1.hh field_names1.hh \
- tracker.h field_types1.hh \
- fields1.hh connection0.hh \
- convert1.hh coldata2.hh \
- compare2.hh connection2.hh \
- query2.hh const_string2.hh \
- convert2.hh datetime2.hh \
- stream2string2.hh field_names2.hh \
- field_types2.hh fields2.hh \
- manip2.hh null2.hh result2.hh \
- row2.hh set2.hh stream2string3.hh \
- sql_query2.hh sql_string2.hh \
- tiny_int2.hh type_info2.hh \
- vallist2.hh coldata3.hh \
- convert3.hh null3.hh compare3.hh \
- connection3.hh const_string3.hh \
- datetime3.hh field_names3.hh \
- field_types3.hh manip3.hh \
- query3.hh result3.hh row3.hh \
- set3.hh sql_query3.hh \
- sql_string3.hh tiny_int3.hh \
- type_info3.hh vallist3.hh \
- custom.hh custom-macros.hh
-
-####### Implicit rules
-
-.SUFFIXES:
-
-%.o: %.cc
-	$(CC) -c $(CFLAGS) $(INCPATH) -o $@ $<
-
-%.o: %.c
-	$(CC) -c $(CFLAGS) $(INCPATH) -o $@ $<
-
-%: %.o
-ifeq ($(TYPE), objs)
-	$(CC) $(CFLAGS) $(LIBS) -o $@ ../sqlplusint/*.o $^
-endif
-ifeq ($(TYPE), static)
-	$(CC) $(CFLAGS) $(NLFLAGS) $(LIBS) -o $@ $^
-endif
-ifeq ($(TYPE), shared)
-	$(CC) $(CFLAGS) $(SLFLAGS) $(LIBS) -o $@ $^
-endif

Index: config.h.in
==================================================================
--- config.h.in
+++ config.h.in
@@ -1,32 +1,80 @@
-/* config.h.in.  Generated automatically from configure.in by autoheader.  */
-
-/* Define to empty if the keyword does not work.  */
-#undef const
-
-/* Define if you have the ANSI C header files.  */
-#undef STDC_HEADERS
-
-/* Define if you have the strtol function.  */
-#undef HAVE_STRTOL
-
-/* Define if you have the intl library (-lintl).  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define if you have __gnu_cxx:slist container in <ext/slist> */
+#undef HAVE_EXT_SLIST
+
+/* Define if you have ::slist container in <slist> */
+#undef HAVE_GLOBAL_SLIST
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the `intl' library (-lintl). */
 #undef HAVE_LIBINTL
 
-/* Define if you have the mysqlclient library (-lmysqlclient).  */
-#undef HAVE_LIBMYSQLCLIENT
-
-/* Define if you have the nsl library (-lnsl).  */
-#undef HAVE_LIBNSL
-
-/* Define if you have the socket library (-lsocket).  */
-#undef HAVE_LIBSOCKET
-
-/* Name of package */
-#undef PACKAGE
-
-/* Version number of package */
-#undef VERSION
-
-/* Define if using the dmalloc debugging malloc package */
-#undef WITH_DMALLOC
-
+/* Define to 1 if you have the `z' library (-lz). */
+#undef HAVE_LIBZ
+
+/* Define if you have the localtime_r() facility */
+#undef HAVE_LOCALTIME_R
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define if your MySQL library has SSL functions */
+#undef HAVE_MYSQL_SSL_SET
+
+/* Define if you have POSIX threads libraries and header files. */
+#undef HAVE_PTHREAD
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define if you have std::slist container in <slist> */
+#undef HAVE_STD_SLIST
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <synch.h> header file. */
+#undef HAVE_SYNCH_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if you have the <zlib.h> header file. */
+#undef HAVE_ZLIB_H
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+#undef PTHREAD_CREATE_JOINABLE
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS

ADDED   config/acx_pthread.m4
Index: config/acx_pthread.m4
==================================================================
--- /dev/null
+++ config/acx_pthread.m4
@@ -0,0 +1,233 @@
+dnl @synopsis ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+dnl
+dnl This macro figures out how to build C programs using POSIX
+dnl threads.  It sets the PTHREAD_LIBS output variable to the threads
+dnl library and linker flags, and the PTHREAD_CFLAGS output variable
+dnl to any special C compiler flags that are needed.  (The user can also
+dnl force certain compiler flags/libs to be tested by setting these
+dnl environment variables.)
+dnl
+dnl Also sets PTHREAD_CC to any special C compiler that is needed for
+dnl multi-threaded programs (defaults to the value of CC otherwise).
+dnl (This is necessary on AIX to use the special cc_r compiler alias.)
+dnl
+dnl NOTE: You are assumed to not only compile your program with these
+dnl flags, but also link it with them as well.  e.g. you should link
+dnl with $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+dnl
+dnl If you are only building threads programs, you may wish to
+dnl use these variables in your default LIBS, CFLAGS, and CC:
+dnl
+dnl        LIBS="$PTHREAD_LIBS $LIBS"
+dnl        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+dnl        CC="$PTHREAD_CC"
+dnl
+dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute
+dnl constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE
+dnl to that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
+dnl
+dnl ACTION-IF-FOUND is a list of shell commands to run if a threads
+dnl library is found, and ACTION-IF-NOT-FOUND is a list of commands
+dnl to run it if it is not found.  If ACTION-IF-FOUND is not specified,
+dnl the default action will define HAVE_PTHREAD.
+dnl
+dnl Please let the authors know if this macro fails on any platform,
+dnl or if you have any other suggestions or comments.  This macro was
+dnl based on work by SGJ on autoconf scripts for FFTW (www.fftw.org)
+dnl (with help from M. Frigo), as well as ac_pthread and hb_pthread
+dnl macros posted by Alejandro Forero Cuervo to the autoconf macro
+dnl repository.  We are also grateful for the helpful feedback of
+dnl numerous users.
+dnl
+dnl @version $Id: acx_pthread.m4 1129 2005-10-04 17:53:10Z wyoung $
+dnl @author Steven G. Johnson <stevenj@alum.mit.edu>
+
+AC_DEFUN([ACX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+AC_LANG_SAVE
+AC_LANG_C
+acx_pthread_ok=no
+
+# We used to check for pthread.h first, but this fails if pthread.h
+# requires special compiler flags (e.g. on True64 or Sequent).
+# It gets checked for in the link test anyway.
+
+# First of all, check if the user has set any of the PTHREAD_LIBS,
+# etcetera environment variables, and if threads linking works using
+# them:
+if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
+        AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)
+        AC_MSG_RESULT($acx_pthread_ok)
+        if test x"$acx_pthread_ok" = xno; then
+                PTHREAD_LIBS=""
+                PTHREAD_CFLAGS=""
+        fi
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+fi
+
+# We must check for the threads library under a number of different
+# names; the ordering is very important because some systems
+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
+# libraries is broken (non-POSIX).
+
+# Create a list of thread flags to try.  Items starting with a "-" are
+# C compiler flags, and other items are library names, except for "none"
+# which indicates that we try without any flags at all, and "pthread-config"
+# which is a program returning the flags for the Pth emulation library.
+
+acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
+
+# The ordering *is* (sometimes) important.  Some notes on the
+# individual items follow:
+
+# pthreads: AIX (must check this before -lpthread)
+# none: in case threads are in libc; should be tried before -Kthread and
+#       other compiler flags to prevent continual compiler warnings
+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
+# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
+# -pthreads: Solaris/gcc
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+#      doesn't hurt to check since this sometimes defines pthreads too;
+#      also defines -D_REENTRANT)
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case "${host_cpu}-${host_os}" in
+        *solaris*)
+
+        # On Solaris (at least, for some versions), libc contains stubbed
+        # (non-functional) versions of the pthreads routines, so link-based
+        # tests will erroneously succeed.  (We need to link with -pthread or
+        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
+        # a function called by this macro, so we could check for that, but
+        # who knows whether they'll stub that too in a future libc.)  So,
+        # we'll just look for -pthreads and -lpthread first:
+
+        acx_pthread_flags="-pthread -pthreads pthread -mt $acx_pthread_flags"
+        ;;
+esac
+
+if test x"$acx_pthread_ok" = xno; then
+for flag in $acx_pthread_flags; do
+
+        case $flag in
+                none)
+                AC_MSG_CHECKING([whether pthreads work without any flags])
+                ;;
+
+                -*)
+                AC_MSG_CHECKING([whether pthreads work with $flag])
+                PTHREAD_CFLAGS="$flag"
+                ;;
+
+		pthread-config)
+		AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no)
+		if test x"$acx_pthread_config" = xno; then continue; fi
+		PTHREAD_CFLAGS="`pthread-config --cflags`"
+		PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+		;;
+
+                *)
+                AC_MSG_CHECKING([for the pthreads library -l$flag])
+                PTHREAD_LIBS="-l$flag"
+                ;;
+        esac
+
+        save_LIBS="$LIBS"
+        save_CFLAGS="$CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Check for various functions.  We must include pthread.h,
+        # since some functions may be macros.  (On the Sequent, we
+        # need a special flag -Kthread to make this header compile.)
+        # We check for pthread_join because it is in -lpthread on IRIX
+        # while pthread_create is in libc.  We check for pthread_attr_init
+        # due to DEC craziness with -lpthreads.  We check for
+        # pthread_cleanup_push because it is one of the few pthread
+        # functions on Solaris that doesn't have a non-functional libc stub.
+        # We try pthread_create on general principles.
+        AC_TRY_LINK([#include <pthread.h>],
+                    [pthread_t th; pthread_join(th, 0);
+                     pthread_attr_init(0); pthread_cleanup_push(0, 0);
+                     pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
+                    [acx_pthread_ok=yes])
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        AC_MSG_RESULT($acx_pthread_ok)
+        if test "x$acx_pthread_ok" = xyes; then
+                break;
+        fi
+
+        PTHREAD_LIBS=""
+        PTHREAD_CFLAGS=""
+done
+fi
+
+# Various other checks:
+if test "x$acx_pthread_ok" = xyes; then
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+	AC_MSG_CHECKING([for joinable pthread attribute])
+	attr_name=unknown
+	for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+	    AC_TRY_LINK([#include <pthread.h>], [int attr=$attr;],
+                        [attr_name=$attr; break])
+	done
+        AC_MSG_RESULT($attr_name)
+        if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
+            AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
+                               [Define to necessary symbol if this constant
+                                uses a non-standard name on your system.])
+        fi
+
+        AC_MSG_CHECKING([if more special flags are required for pthreads])
+        flag=no
+        case "${host_cpu}-${host_os}" in
+            *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;
+            *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;
+        esac
+        AC_MSG_RESULT(${flag})
+        if test "x$flag" != xno; then
+            PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
+        fi
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        # More AIX lossage: must compile with cc_r
+        AC_CHECK_PROG(PTHREAD_CC, cc_r, cc_r, ${CC})
+else
+        PTHREAD_CC="$CC"
+fi
+
+AC_SUBST(PTHREAD_LIBS)
+AC_SUBST(PTHREAD_CFLAGS)
+AC_SUBST(PTHREAD_CC)
+
+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
+if test x"$acx_pthread_ok" = xyes; then
+        ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
+        :
+else
+        acx_pthread_ok=no
+        $2
+fi
+AC_LANG_RESTORE
+])dnl ACX_PTHREAD

ADDED   config/autoconf_inc.m4
Index: config/autoconf_inc.m4
==================================================================
--- /dev/null
+++ config/autoconf_inc.m4
@@ -0,0 +1,110 @@
+dnl ### begin block 00_header[./mysql++.bkl] ###
+dnl
+dnl This macro was generated by
+dnl Bakefile 0.2.3 (http://www.bakefile.org)
+dnl Do not modify, all changes will be overwritten!
+
+BAKEFILE_AUTOCONF_INC_M4_VERSION="0.2.3"
+
+dnl ### begin block 20_COND_BUILD_DEBUG[./mysql++.bkl] ###
+    COND_BUILD_DEBUG="#"
+    if test "x$BUILD" = "xdebug" ; then
+        COND_BUILD_DEBUG=""
+    fi
+    AC_SUBST(COND_BUILD_DEBUG)
+dnl ### begin block 20_COND_BUILD_RELEASE[./mysql++.bkl] ###
+    COND_BUILD_RELEASE="#"
+    if test "x$BUILD" = "xrelease" ; then
+        COND_BUILD_RELEASE=""
+    fi
+    AC_SUBST(COND_BUILD_RELEASE)
+dnl ### begin block 20_COND_DEPS_TRACKING_0[./mysql++.bkl] ###
+    COND_DEPS_TRACKING_0="#"
+    if test "x$DEPS_TRACKING" = "x0" ; then
+        COND_DEPS_TRACKING_0=""
+    fi
+    AC_SUBST(COND_DEPS_TRACKING_0)
+dnl ### begin block 20_COND_DEPS_TRACKING_1[./mysql++.bkl] ###
+    COND_DEPS_TRACKING_1="#"
+    if test "x$DEPS_TRACKING" = "x1" ; then
+        COND_DEPS_TRACKING_1=""
+    fi
+    AC_SUBST(COND_DEPS_TRACKING_1)
+dnl ### begin block 20_COND_PLATFORM_MACOSX_0_USE_SOVERCYGWIN_0_USE_SOVERSION_1[./mysql++.bkl] ###
+    COND_PLATFORM_MACOSX_0_USE_SOVERCYGWIN_0_USE_SOVERSION_1="#"
+    if test "x$PLATFORM_MACOSX" = "x0" -a "x$USE_SOVERCYGWIN" = "x0" -a "x$USE_SOVERSION" = "x1" ; then
+        COND_PLATFORM_MACOSX_0_USE_SOVERCYGWIN_0_USE_SOVERSION_1=""
+    fi
+    AC_SUBST(COND_PLATFORM_MACOSX_0_USE_SOVERCYGWIN_0_USE_SOVERSION_1)
+dnl ### begin block 20_COND_PLATFORM_MACOSX_0_USE_SOVERSION_1[./mysql++.bkl] ###
+    COND_PLATFORM_MACOSX_0_USE_SOVERSION_1="#"
+    if test "x$PLATFORM_MACOSX" = "x0" -a "x$USE_SOVERSION" = "x1" ; then
+        COND_PLATFORM_MACOSX_0_USE_SOVERSION_1=""
+    fi
+    AC_SUBST(COND_PLATFORM_MACOSX_0_USE_SOVERSION_1)
+dnl ### begin block 20_COND_PLATFORM_MACOSX_1[./mysql++.bkl] ###
+    COND_PLATFORM_MACOSX_1="#"
+    if test "x$PLATFORM_MACOSX" = "x1" ; then
+        COND_PLATFORM_MACOSX_1=""
+    fi
+    AC_SUBST(COND_PLATFORM_MACOSX_1)
+dnl ### begin block 20_COND_PLATFORM_MACOSX_1_USE_SOVERSION_1[./mysql++.bkl] ###
+    COND_PLATFORM_MACOSX_1_USE_SOVERSION_1="#"
+    if test "x$PLATFORM_MACOSX" = "x1" -a "x$USE_SOVERSION" = "x1" ; then
+        COND_PLATFORM_MACOSX_1_USE_SOVERSION_1=""
+    fi
+    AC_SUBST(COND_PLATFORM_MACOSX_1_USE_SOVERSION_1)
+dnl ### begin block 20_COND_PLATFORM_MAC_0[./mysql++.bkl] ###
+    COND_PLATFORM_MAC_0="#"
+    if test "x$PLATFORM_MAC" = "x0" ; then
+        COND_PLATFORM_MAC_0=""
+    fi
+    AC_SUBST(COND_PLATFORM_MAC_0)
+dnl ### begin block 20_COND_PLATFORM_MAC_1[./mysql++.bkl] ###
+    COND_PLATFORM_MAC_1="#"
+    if test "x$PLATFORM_MAC" = "x1" ; then
+        COND_PLATFORM_MAC_1=""
+    fi
+    AC_SUBST(COND_PLATFORM_MAC_1)
+dnl ### begin block 20_COND_PLATFORM_OS2_1[./mysql++.bkl] ###
+    COND_PLATFORM_OS2_1="#"
+    if test "x$PLATFORM_OS2" = "x1" ; then
+        COND_PLATFORM_OS2_1=""
+    fi
+    AC_SUBST(COND_PLATFORM_OS2_1)
+dnl ### begin block 20_COND_USE_SOSYMLINKS_1[./mysql++.bkl] ###
+    COND_USE_SOSYMLINKS_1="#"
+    if test "x$USE_SOSYMLINKS" = "x1" ; then
+        COND_USE_SOSYMLINKS_1=""
+    fi
+    AC_SUBST(COND_USE_SOSYMLINKS_1)
+dnl ### begin block 20_COND_USE_SOVERCYGWIN_1_USE_SOVERSION_1[./mysql++.bkl] ###
+    COND_USE_SOVERCYGWIN_1_USE_SOVERSION_1="#"
+    if test "x$USE_SOVERCYGWIN" = "x1" -a "x$USE_SOVERSION" = "x1" ; then
+        COND_USE_SOVERCYGWIN_1_USE_SOVERSION_1=""
+    fi
+    AC_SUBST(COND_USE_SOVERCYGWIN_1_USE_SOVERSION_1)
+dnl ### begin block 20_COND_USE_SOVERLINUX_1[./mysql++.bkl] ###
+    COND_USE_SOVERLINUX_1="#"
+    if test "x$USE_SOVERLINUX" = "x1" ; then
+        COND_USE_SOVERLINUX_1=""
+    fi
+    AC_SUBST(COND_USE_SOVERLINUX_1)
+dnl ### begin block 20_COND_USE_SOVERSION_0[./mysql++.bkl] ###
+    COND_USE_SOVERSION_0="#"
+    if test "x$USE_SOVERSION" = "x0" ; then
+        COND_USE_SOVERSION_0=""
+    fi
+    AC_SUBST(COND_USE_SOVERSION_0)
+dnl ### begin block 20_COND_USE_SOVERSOLARIS_1[./mysql++.bkl] ###
+    COND_USE_SOVERSOLARIS_1="#"
+    if test "x$USE_SOVERSOLARIS" = "x1" ; then
+        COND_USE_SOVERSOLARIS_1=""
+    fi
+    AC_SUBST(COND_USE_SOVERSOLARIS_1)
+dnl ### begin block 20_COND_WINDOWS_IMPLIB_1[./mysql++.bkl] ###
+    COND_WINDOWS_IMPLIB_1="#"
+    if test "x$WINDOWS_IMPLIB" = "x1" ; then
+        COND_WINDOWS_IMPLIB_1=""
+    fi
+    AC_SUBST(COND_WINDOWS_IMPLIB_1)

ADDED   config/libm.m4
Index: config/libm.m4
==================================================================
--- /dev/null
+++ config/libm.m4
@@ -0,0 +1,37 @@
+dnl @synopsis LIB_MATH
+dnl 
+dnl This macro figures out how whether programs using C's math routines
+dnl need to link to libm or not.  This is common on SysV Unices.
+dnl
+dnl @category C
+dnl @author Warren Young <warren@etr-usa.com>
+dnl @version 1.2, 2006-03-06
+
+AC_DEFUN([LIB_MATH],
+[
+	AC_MSG_CHECKING([whether -lm is needed to use C math functions])
+	
+	MYSQLPP_EXTRA_LIBS=
+	TRY_LIBM=no
+	AC_TRY_LINK(
+		[ #include <math.h> ],
+		[ floor(0); ], AC_MSG_RESULT(no), TRY_LIBM=yes)
+
+	if test "x$TRY_LIBM" = "xyes"
+	then
+		save_LIBS=$LIBS
+		LIBS="$LIBS -lm"
+		AC_TRY_LINK(
+			[ #include <math.h> ],
+			[ floor(0); ],
+			[ 
+				MYSQLPP_EXTRA_LIBS=-lm 
+				AC_MSG_RESULT(yes)
+			],
+			AC_MSG_ERROR([Failed to build program containing math functions!]))
+		LIBS="$save_LIBS"
+	fi
+
+	AC_SUBST(MYSQLPP_EXTRA_LIBS)
+])
+

ADDED   config/localtime_r.m4
Index: config/localtime_r.m4
==================================================================
--- /dev/null
+++ config/localtime_r.m4
@@ -0,0 +1,30 @@
+dnl @synopsis AX_C_LOCALTIME_R
+dnl 
+dnl This macro determines whether the C runtime library contains
+dnl localtime_r(), a thread-safe replacement for localtime().
+dnl
+dnl @version 1.0, 2007/02/20
+dnl @author Warren Young <mysqlpp@etr-usa.com>
+AC_DEFUN([AX_C_LOCALTIME_R],
+[
+	AC_MSG_CHECKING([for localtime_r()])
+
+	AC_TRY_RUN([
+		#include <time.h>
+		int main(void)
+		{
+			time_t tt;
+			struct tm stm;
+			localtime_r(&tt, &stm);
+			return 0;
+		}
+	], [localtime_r_found=yes], [localtime_r_found=no], [localtime_r_found=no])
+
+	AC_MSG_RESULT([$localtime_r_found])
+	if test x"$localtime_r_found" = xyes
+	then
+		AC_DEFINE(HAVE_LOCALTIME_R, 1,
+			[Define if you have the localtime_r() facility])
+	fi
+]) dnl AX_C_LOCALTIME_R
+

ADDED   config/mysql++.m4
Index: config/mysql++.m4
==================================================================
--- /dev/null
+++ config/mysql++.m4
@@ -0,0 +1,131 @@
+#-######################################################################
+# mysql++.m4 - Example autoconf macro showing how to find MySQL++
+#	library and header files.
+#
+# Copyright (c) 2004-2008 by Educational Technology Resources, Inc.
+#
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with MySQL++; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+# USA
+#-######################################################################
+
+dnl @synopsis MYSQLPP_DEVEL
+dnl 
+dnl This macro tries to find the MySQL++ library and header files.
+dnl
+dnl We define the following configure script flags:
+dnl
+dnl		--with-mysqlpp: Give prefix for both library and headers, and try
+dnl			to guess subdirectory names for each.  (e.g. tack /lib and
+dnl			/include onto given dir name, and other common schemes.)
+dnl		--with-mysqlpp-lib: Similar to --with-mysqlpp, but for library only.
+dnl		--with-mysqlpp-include: Similar to --with-mysqlpp, but for headers
+dnl			only.
+dnl
+dnl This macro depends on having the default compiler and linker flags
+dnl set up for building programs against the MySQL C API.  The mysql.m4
+dnl macro in this directory fits this bill; run it first.
+dnl
+dnl @version 1.1, 2008/02/07
+dnl @author Warren Young <mysqlpp@etr-usa.com>
+
+AC_DEFUN([MYSQLPP_DEVEL],
+[
+AC_CACHE_CHECK([for MySQL++ devel stuff], ac_cv_mysqlpp_devel,
+[
+	#
+	# Set up configure script macros
+	#
+	AC_ARG_WITH(mysqlpp,
+		[  --with-mysqlpp=<path>     path containing MySQL++ header and library subdirs],
+		[MYSQLPP_lib_check="$with_mysqlpp/lib $with_mysqlpp/lib/mysql++"
+		  MYSQLPP_inc_check="$with_mysqlpp/include $with_mysqlpp/include/mysql++"],
+		[MYSQLPP_lib_check="/usr/local/mysql++/lib /usr/local/lib/mysql++ /opt/mysql++/lib /usr/lib/mysql++ /usr/local/lib /usr/lib"
+		  MYSQLPP_inc_check="/usr/local/mysql++/include /usr/local/include/mysql++ /opt/mysql++/include /usr/local/include/mysql++ /usr/local/include /usr/include/mysql++ /usr/include"])
+	AC_ARG_WITH(mysqlpp-lib,
+		[  --with-mysqlpp-lib=<path> directory path of MySQL++ library],
+		[MYSQLPP_lib_check="$with_mysqlpp_lib $with_mysqlpp_lib/lib $with_mysqlpp_lib/lib/mysql"])
+	AC_ARG_WITH(mysqlpp-include,
+		[  --with-mysqlpp-include=<path> directory path of MySQL++ headers],
+		[MYSQLPP_inc_check="$with_mysqlpp_include $with_mysqlpp_include/include $with_mysqlpp_include/include/mysql"])
+
+	#
+	# Look for MySQL++ library
+	#
+	MYSQLPP_libdir=
+	for dir in $MYSQLPP_lib_check
+	do
+		if test -d "$dir" && \
+			( test -f "$dir/libmysqlpp.so" ||
+			  test -f "$dir/libmysqlpp.a" )
+		then
+			MYSQLPP_libdir=$dir
+			break
+		fi
+	done
+
+	if test -z "$MYSQLPP_libdir"
+	then
+		AC_MSG_ERROR([Didn't find the MySQL++ library dir in '$MYSQLPP_lib_check'])
+	fi
+
+	case "$MYSQLPP_libdir" in
+		/* ) ;;
+		* )  AC_MSG_ERROR([The MySQL++ library directory ($MYSQLPP_libdir) must be an absolute path.]) ;;
+	esac
+
+	AC_MSG_RESULT([lib in $MYSQLPP_libdir])
+
+	case "$MYSQLPP_libdir" in
+	  /usr/lib) ;;
+	  *) LDFLAGS="$LDFLAGS -L${MYSQLPP_libdir}" ;;
+	esac
+
+
+	#
+	# Look for MySQL++ headers
+	#
+	AC_MSG_CHECKING([for MySQL++ header directory])
+	MYSQLPP_incdir=
+	for dir in $MYSQLPP_inc_check
+	do
+		if test -d "$dir" && test -f "$dir/mysql++.h"
+		then
+			MYSQLPP_incdir=$dir
+			break
+		fi
+	done
+
+	if test -z "$MYSQLPP_incdir"
+	then
+		AC_MSG_ERROR([Didn't find the MySQL++ header dir in '$MYSQLPP_inc_check'])
+	fi
+
+	case "$MYSQLPP_incdir" in
+		/* ) ;;
+		* )  AC_MSG_ERROR([The MySQL++ header directory ($MYSQLPP_incdir) must be an absolute path.]) ;;
+	esac
+
+	AC_MSG_RESULT([$MYSQLPP_incdir])
+
+	CPPFLAGS="$CPPFLAGS -I${MYSQLPP_incdir}"
+
+	AC_MSG_CHECKING([that we can build MySQL++ programs])
+	AC_COMPILE_IFELSE(
+		[AC_LANG_PROGRAM([#include <mysql++.h>],
+		[mysqlpp::Connection c(false)])],
+		ac_cv_mysqlpp_devel=yes,
+		AC_MSG_ERROR(no))
+])]) dnl End MYSQLPP_DEVEL
+

ADDED   config/mysql_loc.m4
Index: config/mysql_loc.m4
==================================================================
--- /dev/null
+++ config/mysql_loc.m4
@@ -0,0 +1,112 @@
+dnl @synopsis MYSQL_API_LOCATION
+dnl 
+dnl This macro tries to find MySQL C API header and library locations.
+dnl
+dnl We define the following configure script flags:
+dnl
+dnl		--with-mysql: Give prefix for both library and headers, and try
+dnl			to guess subdirectory names for each.  (e.g. Tack /lib and
+dnl			/include onto given dir name, and other common schemes.)
+dnl		--with-mysql-lib: Similar to --with-mysql, but for library only.
+dnl		--with-mysql-include: Similar to --with-mysql, but for headers
+dnl			only.
+dnl
+dnl @version 1.2, 2007/02/20
+dnl @author Warren Young <mysqlpp@etr-usa.com>
+AC_DEFUN([MYSQL_API_LOCATION],
+[
+	#
+	# Set up configure script macros
+	#
+	AC_ARG_WITH(mysql,
+		[  --with-mysql=<path>     root directory path of MySQL installation],
+		[MYSQL_lib_check="$with_mysql/lib/mysql $with_mysql/lib"
+		MYSQL_inc_check="$with_mysql/include $with_mysql/include/mysql"],
+		[MYSQL_lib_check="/usr/lib64 /usr/lib /usr/lib64/mysql /usr/lib/mysql /usr/local/lib64 /usr/local/lib /usr/local/lib/mysql /usr/local/mysql/lib /usr/local/mysql/lib/mysql /opt/mysql/lib /opt/mysql/lib/mysql"
+		MYSQL_inc_check="/usr/include/mysql /usr/local/include/mysql /usr/local/mysql/include /usr/local/mysql/include/mysql /opt/mysql/include/mysql"])
+	AC_ARG_WITH(mysql-lib,
+		[  --with-mysql-lib=<path> directory path of MySQL library installation],
+		[MYSQL_lib_check="$with_mysql_lib $with_mysql_lib/lib64 $with_mysql_lib/lib $with_mysql_lib/lib64/mysql $with_mysql_lib/lib/mysql"])
+	AC_ARG_WITH(mysql-include,
+		[  --with-mysql-include=<path> directory path of MySQL header installation],
+		[MYSQL_inc_check="$with_mysql_include $with_mysql_include/include $with_mysql_include/include/mysql"])
+
+	#
+	# Decide which C API library to use, based on thread support
+	#
+	if test "x$acx_pthread_ok" = xyes
+	then
+		MYSQL_C_LIB=mysqlclient_r
+	else
+		MYSQL_C_LIB=mysqlclient
+	fi
+
+	#
+	# Look for MySQL C API library
+	#
+	AC_MSG_CHECKING([for MySQL library directory])
+	MYSQL_libdir=
+	for m in $MYSQL_lib_check
+	do
+		if test -d "$m" && \
+			(test -f "$m/lib$MYSQL_C_LIB.so" || test -f "$m/lib$MYSQL_C_LIB.a")
+		then
+			MYSQL_libdir=$m
+			break
+		fi
+	done
+
+	if test -z "$MYSQL_libdir"
+	then
+		AC_MSG_ERROR([Didn't find $MYSQL_C_LIB library in '$MYSQL_lib_check'])
+	fi
+
+	case "$MYSQL_libdir" in
+		/* ) ;;
+		* )  AC_MSG_ERROR([The MySQL library directory ($MYSQL_libdir) must be an absolute path.]) ;;
+	esac
+
+	AC_MSG_RESULT([$MYSQL_libdir])
+
+	case "$MYSQL_libdir" in
+	  /usr/lib) ;;
+	  *) LDFLAGS="$LDFLAGS -L${MYSQL_libdir}" ;;
+	esac
+
+
+	#
+	# Look for MySQL C API headers
+	#
+	AC_MSG_CHECKING([for MySQL include directory])
+	MYSQL_incdir=
+	for m in $MYSQL_inc_check
+	do
+		if test -d "$m" && test -f "$m/mysql.h"
+		then
+			MYSQL_incdir=$m
+			break
+		fi
+	done
+
+	if test -z "$MYSQL_incdir"
+	then
+		AC_MSG_ERROR([Didn't find the MySQL include dir in '$MYSQL_inc_check'])
+	fi
+
+	case "$MYSQL_incdir" in
+		/* ) ;;
+		* )  AC_MSG_ERROR([The MySQL include directory ($MYSQL_incdir) must be an absolute path.]) ;;
+	esac
+
+	AC_MSG_RESULT([$MYSQL_incdir])
+
+	CPPFLAGS="$CPPFLAGS -I${MYSQL_incdir}"
+
+	save_LIBS=$LIBS
+	LIBS="$LIBS $MYSQLPP_EXTRA_LIBS"
+	AC_CHECK_LIB($MYSQL_C_LIB, mysql_store_result, [], [
+			AC_MSG_ERROR([Could not find working MySQL client library!]) ])
+	AC_SUBST(MYSQL_C_LIB)
+	LIBS=$save_LIBS
+]) dnl MYSQL_API_LOCATION
+

ADDED   config/mysql_ssl.m4
Index: config/mysql_ssl.m4
==================================================================
--- /dev/null
+++ config/mysql_ssl.m4
@@ -0,0 +1,17 @@
+dnl @synopsis MYSQL_WITH_SSL
+dnl
+dnl This macro determines whether mysql_ssl_set() API call exists.
+dnl Requires at least MySQL 4.0.1. 
+dnl 
+dnl @version $Id$, $Date$
+dnl @author Ovidiu Bivolaru <ovidiu@targujiu.rdsnet.ro>
+AC_DEFUN([MYSQL_WITH_SSL],
+[
+    #
+    # Check for mysql_ssl_set() in libmysqlclient(_r)
+    #
+    AC_CHECK_LIB($MYSQL_C_LIB, mysql_ssl_set, [
+	AC_DEFINE(HAVE_MYSQL_SSL_SET,, Define if your MySQL library has SSL functions)
+    ]) dnl AC_CHECK_LIB(mysqlclient, mysql_ssl_set)
+]) dnl  MYSQL_WITH_SSL
+

ADDED   config/socket_nsl.m4
Index: config/socket_nsl.m4
==================================================================
--- /dev/null
+++ config/socket_nsl.m4
@@ -0,0 +1,72 @@
+dnl @synopsis LIB_SOCKET_NSL
+dnl 
+dnl This macro figures out what libraries are required on this platform
+dnl to link sockets programs.
+dnl
+dnl The common cases are not to need any extra libraries, or to need
+dnl -lsocket and -lnsl.  We need to avoid linking with libnsl unless
+dnl we need it, though, since on some OSes where it isn't necessary it
+dnl will totally break networking.  Unisys also includes gethostbyname()
+dnl in libsocket but needs libnsl for socket().
+dnl
+dnl @category Misc
+dnl @author Warren Young <mysqlpp@etr-usa.com>
+dnl @version 1.5, 2006-03-06
+
+AC_DEFUN([LIB_SOCKET_NSL],
+[
+	save_LIBS="$LIBS"
+
+	AC_MSG_CHECKING([whether -lsocket is needed])
+	TRY_LSOCKET=no
+	AC_TRY_LINK(
+		[ 
+			#include <sys/types.h>
+			#include <sys/socket.h> 
+			#include <netinet/in.h>
+			#include <arpa/inet.h>
+		],
+		[ socket(AF_INET, SOCK_STREAM, 0); ],
+		AC_MSG_RESULT(no), TRY_LSOCKET=yes)
+
+	if test "x$TRY_LSOCKET" = "xyes"
+	then
+		LIBS="-lsocket $LIBS"
+		AC_TRY_LINK(
+			[ 
+				#include <sys/types.h>
+				#include <sys/socket.h> 
+				#include <netinet/in.h>
+				#include <arpa/inet.h>
+			],
+			[ socket(AF_INET, SOCK_STREAM, 0); ],
+			[ 
+				MYSQLPP_EXTRA_LIBS="-lsocket $MYSQLPP_EXTRA_LIBS"
+				AC_MSG_RESULT(yes)
+			],
+			AC_MSG_ERROR([failed to link using -lsocket!]))
+	fi
+
+	AC_MSG_CHECKING([whether -lnsl is needed])
+	TRY_LNSL=no
+	AC_TRY_LINK(
+		[ #include <netdb.h> ],
+		[ gethostbyname("gna.org"); ],
+		AC_MSG_RESULT(no), TRY_LNSL=yes)
+
+	if test "x$TRY_LNSL" = "xyes"
+	then
+		LIBS="-lnsl $LIBS"
+		AC_TRY_LINK(
+			[ #include <netdb.h> ],
+			[ gethostbyname("gna.org"); ],
+			[ 
+				MYSQLPP_EXTRA_LIBS="-lnsl $MYSQLPP_EXTRA_LIBS"
+				AC_MSG_RESULT(yes)
+			],
+			AC_MSG_ERROR([failed to link using -lnsl!]))
+	fi
+
+	AC_SUBST(MYSQLPP_EXTRA_LIBS)
+])
+

ADDED   config/stl_slist.m4
Index: config/stl_slist.m4
==================================================================
--- /dev/null
+++ config/stl_slist.m4
@@ -0,0 +1,55 @@
+dnl @synopsis STL_SLIST_EXTENSION
+dnl 
+dnl This macro determines whether the local STL implementation includes
+dnl a singly-linked list template, slist, and if so, where it is.
+dnl
+dnl @version 1.2, 2005/07/22
+dnl @author Warren Young <mysqlpp@etr-usa.com>
+AC_DEFUN([STL_SLIST_EXTENSION],
+[
+	AC_MSG_CHECKING([for STL slist extension])
+
+	AC_COMPILE_IFELSE(
+		[AC_LANG_PROGRAM(
+			[#include <slist>],
+			[slist<int> l])],
+		AC_DEFINE(HAVE_GLOBAL_SLIST, 1,
+			[ Define if you have ::slist container in <slist> ]),
+		TRY_NEXT=yes)
+
+	if test -z "$TRY_NEXT"
+	then
+		SLIST_LOC="<slist>, global scope"
+	else
+		TRY_NEXT=""
+		AC_COMPILE_IFELSE(
+			[AC_LANG_PROGRAM(
+				[#include <slist>],
+				[std::slist<int> l])],
+			AC_DEFINE(HAVE_STD_SLIST, 1,
+				[ Define if you have std::slist container in <slist> ]),
+			TRY_NEXT=yes)
+
+		if test -z "$TRY_NEXT"
+		then
+			SLIST_LOC="<slist>, namespace std"
+		else
+			TRY_NEXT=""
+			AC_COMPILE_IFELSE(
+				[AC_LANG_PROGRAM(
+					[#include <ext/slist>],
+					[__gnu_cxx::slist<int> l])],
+				AC_DEFINE(HAVE_EXT_SLIST, 1,
+					[ Define if you have __gnu_cxx:slist container in <ext/slist> ]),
+				SLIST_LOC="not found")
+
+			if test -z "$SLIST_LOC"
+			then
+				SLIST_LOC="<ext/slist>, namespace __gnu_cxx"
+			fi
+		fi
+	fi
+
+	AC_MSG_RESULT([$SLIST_LOC])
+]) dnl STL_SLIST_EXTENSION
+

ADDED   configure.ac
Index: configure.ac
==================================================================
--- /dev/null
+++ configure.ac
@@ -0,0 +1,86 @@
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with MySQL++; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+# USA
+
+# Standard autotools stuff
+AC_INIT(mysql++, 3.0.3, plusplus@lists.mysql.com, mysql++)
+AC_CONFIG_HEADER(config.h)
+AC_DISABLE_STATIC
+AC_CANONICAL_SYSTEM
+
+
+# Break package version up into major, minor and bugfix components.
+MYSQLPP_VERSION_MAJOR=`echo $PACKAGE_VERSION | cut -f1 -d.`
+AC_SUBST(MYSQLPP_VERSION_MAJOR)
+MYSQLPP_VERSION_MINOR=`echo $PACKAGE_VERSION | cut -f2 -d.`
+AC_SUBST(MYSQLPP_VERSION_MINOR)
+MYSQLPP_VERSION_BUGFIX=`echo $PACKAGE_VERSION | cut -f3 -d.`
+AC_SUBST(MYSQLPP_VERSION_BUGFIX)
+
+
+# Include Bakefile macros
+AC_BAKEFILE([m4_include(config/autoconf_inc.m4)])
+
+
+# Check for Standard C support
+AC_PROG_CC
+AC_HEADER_STDC
+
+
+# Figure out whether/how to handle threading support, if available.
+AC_ARG_ENABLE(thread-check,
+		[  --enable-thread-check  Check for threads, and use if available. ],
+		[ thread_check=yes ])
+if test "x$thread_check" = "xyes"
+then
+	ACX_PTHREAD
+	LIBS="$PTHREAD_LIBS $LIBS"
+	CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+	CC="$PTHREAD_CC"
+fi
+
+
+# Checks for libraries and local system features
+AC_CHECK_HEADERS(zlib.h, AC_CHECK_LIB(z, gzread, [],
+		[ AC_MSG_ERROR([zlib is required]) ]))
+AC_CHECK_HEADERS(synch.h)
+LIB_MATH
+LIB_SOCKET_NSL
+MYSQL_API_LOCATION
+MYSQL_WITH_SSL
+AX_C_LOCALTIME_R
+AC_CHECK_LIB(intl, main)
+
+
+# If this is Cygwin, add a linker flag to suppress a silly link message.
+case "${host}" in
+	*cygwin*)
+		LDFLAGS="$LDFLAGS -Wl,--enable-auto-import"
+		;;
+esac
+
+
+# Check for Standard C++ support, and extensions.  This must be near
+# the end, because the CPLUSPLUS directive makes autoconf use C++
+# compiler for all subsequent tests!
+AC_PROG_CXX
+AC_LANG_CPLUSPLUS
+STL_SLIST_EXTENSION
+
+
+#
+# Configure process complete; write out files generated from *.in.
+#
+AC_OUTPUT([Makefile mysql++.spec doc/userman/userman.dbx lib/Doxyfile lib/mysql++.h])
+

DELETED configure.in
Index: configure.in
==================================================================
--- configure.in
+++ /dev/null
@@ -1,58 +0,0 @@
-dnl Process this file with autoconf to produce a configure script.
-AC_INIT(sqlplusint/sqlplus.hh)
-
-VERSION=`cat ${srcdir}/.version`
-SQLPLUS_MAJOR_VERSION=[`expr $VERSION : '\([0-9][0-9]*\)'`]
-AC_SUBST(SQLPLUS_MAJOR_VERSION)
-SQLPLUS_MINOR_VERSION=[`expr $VERSION : '[0-9][0-9]*\.\([0-9][0-9]*\)'`]
-AC_SUBST(SQLPLUS_MINOR_VERSION)
-SQLPLUS_MICRO_VERSION=[`expr $VERSION : '[0-9][0-9]*\.[0-9][0-9]*\.\([0-9][0-9]*\)'`]
-AC_SUBST(SQLPLUS_MICRO_VERSION)
-AM_INIT_AUTOMAKE(sqlplus, $VERSION)
-
-AM_CONFIG_HEADER(config.h)
-
-AC_PROG_MAKE_SET
-
-AM_PROG_LIBTOOL
-
-dnl Initialize maintainer mode
-AM_MAINTAINER_MODE
-
-#
-# Location of MySQL installation
-#
-MYSQL_HOME=/usr/local
-if test ! -d "${MYSQL_HOME}/include/mysql"
-then
-	MYSQL_HOME=/usr
-fi
-AC_CACHE_CHECK([MYSQL_HOME], webbase_cv_mysql_home,
-AC_ARG_WITH(mysql,
-    [  --with-mysql=<path> root directory path of MySQL installation],
-    [MYSQL_HOME=$with_mysql])
-webbase_cv_mysql_home=${MYSQL_HOME}
-)
-AC_SUBST(MYSQL_HOME)
-LDFLAGS="$LDFLAGS -L${MYSQL_HOME}/lib/mysql"
-CPPFLAGS="$CPPFLAGS -I${MYSQL_HOME}/include/mysql"
-
-AC_PROG_CC
-AC_PROG_CXX
-
-AC_CHECK_LIB(intl, main)
-AC_CHECK_LIB(socket, main)
-AC_CHECK_LIB(nsl, main)
-AC_CHECK_LIB(mysqlclient, mysql_store_result)
-AM_WITH_DMALLOC()
-
-dnl Checks for header files.
-AC_HEADER_STDC
-
-dnl Checks for typedefs, structures, and compiler characteristics.
-AC_C_CONST
-
-dnl Checks for library functions.
-AC_CHECK_FUNCS(strtol)
-
-AC_OUTPUT(Makefile sqlplusint/Makefile examples/Makefile)

DELETED doc/Makefile
Index: doc/Makefile
==================================================================
--- doc/Makefile
+++ /dev/null
@@ -1,29 +0,0 @@
-# this is a makefile for making a manual
-
-default: manual
-
-perlclean: 
-	-rm -f manual.txt manual.html
-	$(MAKE) -C ../sqlplusint/ perlclean
-
-manual:
-	$(MAKE) -C ../sqlplusint/  classref
-	perl insert-classref.pl
-	-rm -f -r man-html
-	-mkdir man-html
-	perl examples-proc.pl
-	latex manual.tex
-	latex manual.tex
-	latex2html \
-	  -split 3 \
-	  -toc_depth 3 \
-	  -dir man-html \
-	  -long_titles 2 \
-	  -local_icons \
-	  -show_section_numbers \
-	   manual.tex
-
-	-rm -f -r man-text
-	-mkdir man-text
-	perl html2txt.pl
-

ADDED   doc/README-devel-RPM.txt
Index: doc/README-devel-RPM.txt
==================================================================
--- /dev/null
+++ doc/README-devel-RPM.txt
@@ -0,0 +1,10 @@
+mysql++-devel RPM installs the files you need when building your own
+MySQL++ based programs, as well as documentation and examples that
+can help you learn how to use the library.
+
+The MySQL++ header files are in /usr/include/mysql++, the library
+is in /usr/lib, and the example programs' source code is in
+/usr/share/doc/mysql++-devel-*/examples.  For more information on
+the examples, see the README-examples.txt file in the directory
+containing the examples.
+

ADDED   doc/README-manuals-RPM.txt
Index: doc/README-manuals-RPM.txt
==================================================================
--- /dev/null
+++ doc/README-manuals-RPM.txt
@@ -0,0 +1,5 @@
+For more information about MySQL++, see its home page:
+
+	http://tangentsoft.net/mysql++/
+
+See the LICENSE file in this directory for the library's license.

DELETED doc/doc-fix.pl
Index: doc/doc-fix.pl
==================================================================
--- doc/doc-fix.pl
+++ /dev/null
@@ -1,22 +0,0 @@
-$/ = undef;
-
-open F, $ARGV[0];
-
-$_=<F>;
-
-s~\\begin_inset LatexCommand \\ref.+
-\\end_inset
-(.+)
-\\begin_inset LatexDel .+
-\\end_inset
-.+
-\\begin_inset LatexDel .+
-\\end_inset
-~\\begin_inset LatexCommand \\ref\{$1\}
-
-\\end_inset
-~g;
-
-open F, ">$ARGV[0]";
-print F $_;
-

DELETED doc/doc-trim.pl
Index: doc/doc-trim.pl
==================================================================
--- doc/doc-trim.pl
+++ /dev/null
@@ -1,11 +0,0 @@
-$/ = undef;
-
-open F, $ARGV[0];
-
-$_=<F>;
-
-/(\\layout Section.+)\\the_end/s;
-
-open F, ">$ARGV[0]";
-print F $1;
-

DELETED doc/doc.tex.tmpl
Index: doc/doc.tex.tmpl
==================================================================
--- doc/doc.tex.tmpl
+++ /dev/null
@@ -1,193 +0,0 @@
-#ptags [ ]
-[!autolink]
-
-[foreach class]
-\section{[class]}
-\label{[filter ref][class dont_filter][endfilter]}
-
-[if templ]template [endif] \
-[if struct]struct[endif][else][if union]union[endif][else]class[endelse][endelse] \
-\textbf{[class]}[templ]
-
-[if parents]\textbf{Parents:} [parents][endif]
-
-[if with_class][if with_class != [class]]
-  \textbf{Related to:} [with_class] \
-  (\ref{[filter ref][with_class dont_filter][endfilter]})
-[endif][endif]
-
-[if brief]\textit{[brief]}[endif]
-
-[detail]
-
-\subsection{Synopses}
-
-[if public]
-\textbf{Public members:}
-\begin{itemize}
-[foreach public]
-\item [if pure]pure [endif][type] \textbf{[mname]} \
-  [if func] \
-    ([args]) [if const] const [endif] \
-    [if throws] throws [throwclass]([throwargs])[endif] \
-  [endif] \
-  [if enum] [lb][args][rb] [endif] \
-  [if detail] (\ref{[filter ref][class dont_filter]::[member dont_filter][endfilter]}) [endif] \
-  [if brief] - \textit{[brief]}[endif] \
-[next]
-
-\end{itemize}
-[endif]
-
-[if protected]
-\textbf{Protected members:}
-\begin{itemize}
-
-[foreach protected]
-\item [if pure]pure [endif][type] \textbf{[mname]} \
-  [if func] \
-    ([args]) [if const] const [endif] \
-    [if throws] throws [throwclass]([throwargs])[endif] \
-  [endif] \
-  [if enum] [lb][args][rb] [endif] \
-  [if detail] (\ref{[filter ref][class dont_filter]::[member dont_filter][endfilter]}) [endif] \
-  [if brief] - \textit{[brief]}[endif] \
-[next]
-
-\end{itemize}
-[endif]
-
-[nobreak]
-[foreach func]
-[if with_class == [class]]
-[if !l1][def l1]
-    \textbf{Related Functions} [n]
-    [n]
-    \begin{itemize} [n]
-[endif]
-\item [type] \textbf{[name]} ([args]) 
-    [if throws] throws [throwclass]([throwargs]) [endif] 
-    [if brief] -  \textit{[brief]}[endif] [n]
-[endif]
-[next]
-[if l1] [undef l1]
-  \end{itemize} [n]
-[endif]
-[endnobreak]
-
-[nobreak]
-[foreach typedef]
-[if with_class == [class]]
-  [if !l1] [def l1]
-    \textbf{Related Types} [n]
-    [n]
-    \begin{itemize} [n]
-  [endif]
-\item [if typedef]typedef [endif][if enum]enum [endif][type] \textbf{[name]}
-  [if enum] [lb][args][rb] [endif]
-  [if brief] - \textit{[brief]}[endif] [n]
-[endif]
-[next]
-[if l1] [undef l1]
-  \end{itemize} [n]
-[endif]
-[endnobreak]
-
-[nobreak]
-[def pclass [class]]
-[foreach class]
-[if with_class == [pclass]] [if with_class != [class]]
-[if !l1] [def l1]	
-  \textbf{Related Classes} [n]
-  [n]
-  \begin{itemize} [n]
-[endif]
-\item [if templ]template [endif] 
-  [if struct]struct[endif][else][if union]union[endif][else]class[endelse][endelse] 
-    \textbf{[class]}[templ] 
-    (\ref{[filter ref][class dont_escape][endfilter]}) 
-    [if brief] - \textit{[brief]} [endif] [n]
-[endif] [endif]
-[next]
-[if l1] [undef l1]
-  \end{itemize} [n]
-[endif]
-[undef pclass]
-[endnobreak]
-
-[foreach public]
-[if detail]
-\subsection{[member]}
-\label{[filter ref][class dont_filter]::[member dont_filter][endfilter]}
-
-  [if pure]pure [endif][type] \textbf{[mname]} \
-  [if func] \
-    ([args]) [if const] const [endif] \
-    [if throws] throws [throwclass]([throwargs])[endif] \
-  [endif] \
-  [if enum] [lb][args][rb] [endif]
-
-[if brief]\textit{[brief]}[endif]
-
-[detail]
-
-[endif]
-
-[next]
-
-[foreach func][if with_class == [class]][// ][if detail]
-\subsection{[name]}
-
-[type] \textbf{[name]} ([args]) \
-  [if throws] throws [throwclass]([throwargs]) [endif]
-
-[if brief]\textit{[brief]}[endif]
-
-[detail]
-
-[endif][endif][next]
-
-[next]
-
-
-\section{Misc Non Members}
-
-[foreach func][if !with_class]
-[if !f1] [def f1]
-  \textbf{Functions:}
-  \begin{itemize}
-[endif]
-\item [type] \textbf{[name]} ([args]) \
-  [if throws] throws [throwclass]([throwargs]) [endif] \
-  [if brief] -  \textit{[brief]}[endif] 
-[endif][next]
-[if f1] [undef f1]
-\end{itemize}
-[endif]
-
-[foreach typedef][if !with_class]
-[if !tl] [def tl]
-  \textbf{Types:}
-  \begin{itemize}
-[endif]
-\item [if typedef]typedef [endif][if enum]enum [endif][type] \textbf{[name]}
-  [if enum] [lb][args][rb] [endif]
-  [if brief] - \textit{[brief]}[endif]
-[endif][next]
-[if tl] [undef tl]
-\end{itemize}
-[endif]
-
-[foreach func]
-[if detail][if !with_class]
-\subsection{[name]}
-
-[type] \textbf{[name]} ([args]) \
-  [if throws] throws [throwclass]([throwargs]) [endif]
-
-[if brief]\textit{[brief]}[endif]
-
-[detail]
-
-[endif][endif]
-[next]

DELETED doc/examples-proc.pl
Index: doc/examples-proc.pl
==================================================================
--- doc/examples-proc.pl
+++ /dev/null
@@ -1,20 +0,0 @@
-
-$/ = undef;
-open IN, "manual.tex";
-$_ = <IN>;
-
-s/\\begin\{comment\}[\n\s]+example:(\S+)[\n\s]*\\end\{comment\}[\n\s]*/${\(&ie($1))}/sg;
-
-open IN, ">manual.tex";
-print IN;
-
-sub ie {
-  my $return;
-  $return  = "\n";
-  $return .= "\\begin{verbatim}\n";
-  open EIN, "examples/$_[0]";
-  local $/ = undef;
-  $return .= <EIN>;
-  $return .= "\\end{verbatim}\n\n";
-  return $return;
-}

DELETED doc/html2txt.pl
Index: doc/html2txt.pl
==================================================================
--- doc/html2txt.pl
+++ /dev/null
@@ -1,7 +0,0 @@
-opendir DIR, "man-html";
-
-foreach (readdir(DIR)) {
-  next unless /(.+?)\.html$/;
-  print "lynx -dump man-html/$_ > man-text/$1.txt\n" ;
-  system "lynx -dump man-html/$_ > man-text/$1.txt" ;
-}

DELETED doc/insert-classref.pl
Index: doc/insert-classref.pl
==================================================================
--- doc/insert-classref.pl
+++ /dev/null
@@ -1,22 +0,0 @@
-$/ = undef;
-
-open F, "manual.tex";
-open CR, "../sqlplusint/doc.tex";
-
-$_=<F>;
-$classref=<CR>;
-
-s~\\begin{comment}[\s\n]*Begin Class Ref[\s\n]*\\end{comment}.+?\\begin{comment}[\s\n]*End Class Ref[\s\n]*\\end{comment}~
-\\begin{comment}
-Begin Class Ref
-\\end{comment}
-$classref
-\\begin{comment}
-End Class Ref
-\\end{comment}
-~s || die "Could not insert classref\n";
-
-open F, ">manual.tex";
-print F $_; 
-
-

DELETED doc/manual.lyx
Index: doc/manual.lyx
==================================================================
--- doc/manual.lyx
+++ /dev/null
@@ -1,13211 +0,0 @@
-#This file was created by <Sinisa> Thu Nov 25 16:06:21 1999
-#LyX 0.12 (C) 1995-1998 Matthias Ettrich and the LyX Team
-\lyxformat 2.15
-\textclass book
-\begin_preamble
-\usepackage{html}
-
-\begin{htmlonly}
-
-\renewenvironment{lyxcode}
-  {\begin{list}{}{
-    \setlength{\rightmargin}{\leftmargin}
-    \raggedright
-    \setlength{\itemsep}{0pt}
-    \setlength{\parsep}{0pt}
-    \ttfamily}%
-   \item[] 
-   \begin{ttfamily}}
-   {\end{ttfamily}
-    \end{list} }
-
-\newenvironment{LyXParagraphIndent}[1]%
-{\begin{quote}}
-{\end{quote}}
-
-\end{htmlonly}
-\end_preamble
-\language default
-\inputencoding default
-\fontscheme default
-\graphics default
-\float_placement h
-\paperfontsize 11
-\spacing single 
-\papersize Default
-\paperpackage a4
-\use_geometry 1
-\use_amsmath 0
-\paperorientation portrait
-\leftmargin 1in
-\rightmargin 1in
-\secnumdepth 2
-\tocdepth 2
-\paragraph_separation skip
-\defskip medskip
-\quotes_language english
-\quotes_times 2
-\papercolumns 1
-\papersides 1
-\paperpagestyle default
-
-\layout Title
-
-Mysql++ 
-\newline 
-A C++ API for Mysql
-\newline 
-ver 1.4
-\layout Author
-
-Kevin Atkinson
-\newline 
-(kevinatk@home.com)
-\newline 
- Sinisa Milivojevic
-\newline 
-(sinisa@cytanet.com.cy)
-\newline 
-Michael Widenius
-\newline 
-(monty@mysql.com)
-\layout Standard
-
-
-\begin_inset LatexCommand \tableofcontents
-
-\end_inset 
-
-
-\layout Part*
-
-Introductory Material
-\layout Chapter
-
-Introduction
-\layout Section
-
-What is Mysql++
-\layout Standard
-
-Mysql++ is a complex C++ API for Mysql (And other SQL Databases Soon).
- The goal of this API is too make working with Queries as easy as working
- with other STL Containers.
- See the Overview chapter (
-\begin_inset LatexCommand \ref{Overview}
-
-\end_inset 
-
-) for the components that make up Mysql++.
-\layout Section
-
-Getting Mysql++
-\layout Standard
-
-The latest version of Mysql++ can be found at the mysql++ web site at http://www.
-mysql.com/mysql++.
-\layout Section
-
-Mysql++ Mailing List
-\layout Standard
-
-Instructions for joining the mailing list (and an archive of the mailing
- list) can be found off the Mysql++ home page at http://www.mysql.com/mysql++
-\layout Chapter
-
-Overview
-\layout Standard
-
-
-\begin_inset LatexCommand \label{Overview}
-
-\end_inset 
-
-The Mysql++ API has developed into a very complex and powerful being.
- With many different ways to accomplish the same task.
- Unfortunately this means that figuring out how to perform a simple task
- can be frustrating for new users of my library.
- In this section I will attempt to provide an overview of the many different
- components of the library.
-\layout Standard
-
-Like working with most other SQL API the process for executing queries is
- the same.
- 1) You open the connection, 2) You form and execute the queries, 3) You
- iterate through the result set.
- It not much different in my C++ API.
- However there is a lot of extra functionality along each step of the way.
-\layout Section*
-
-The Main Database Handle
-\layout Standard
-
-This is a class that handles the connection to the Mysql server.
- You always need at least one of these objects to do anything.
- It can either create a separate queries object or directly execute queries.
- The separate query object is the recommended way as it gives you far more
- power.
-\layout Section*
-
-The Query Object
-\layout Standard
-
-This object is the recommended way of executing queries.
- It is subclassed from strstream which means you can write to it like any
- other stream to aid in the formation of queries.
-\layout Standard
-
-You can also set up Template queries with this class.
- Template queries are a way of setting up queries with replaceable parameters
- that you can change throughout your program.
-\layout Standard
-
-You can also use specialized structures and even the dramatic result sets
- to aid in creating queries however more on that latter.
-\layout Standard
-
-The Query object returns an object with information about the success of
- a query for non-select queries (queries that don't return a result set).
-\layout Section*
-
-The Result Sets
-\layout Standard
-
-For queries that return a result set you have essentially two different
- ways of handling the results: in a dramatic result set, or in a static
- one.
-\layout Subsection*
-
-The Dramatic Result Set
-\layout Standard
-
-The Dramatic Result set is a result set in which the names of the columns
- and the type of information of the columns does not need to be determined
- at compile time.
- The result set can be completely constant in which the data is returned
- to you in a constant string link class, semi-constant in which you can
- modify the data one row at a time, or a truly mutable in which in you can
- modify the data in any way you like.
-\layout Standard
-
-The constant result set is a result set that is closely bound to the result
- set in the C API and is the one that provides the most functionality.
- With this result set you can find out detailed information about the type
- of information stored in each of the columns.
- This is also the fastest because the data does not need to be copied at
- all.
-\layout Standard
-
-The semi-constant result set is like the constant result set except you
- can modify the data one row at a time.
- The data you modify is actually a copy of the data returned by the server.
- This means that modifying the data does not change the actual result set
- at all.
-\layout Standard
-
-The semi-constant result set is actually the same thing as the constant
- result set.
- The only difference is that when you request a row from the result set
- you specifically declare the row as a mutable one.
- This means that you can get some rows back as constant rows and others
- as mutable ones.
-\layout Standard
-
-The truly mutable result set is a result set similar to the constant one
- except that the data is truly mutable in the sense that you can change
- the data in the actual result set.
- However unlike the first one this result set is not bound to the C API
- result set.
- Instead it containers a copy of the data returned by the C API in a two-dimensi
-onal vector.
- Because of this the detailed information about each of the columns is not
- currently available, only the column names and the C++ type that most closely
- matches the original SQL type.
- Also, because it makes a copy of the data returned from the C API, there
- is a little bit of performance penalty to using this one.
-\layout Standard
-
-The rows in all the dramatic result sets are very close to an Standard Template
- Library (STL) random access container.
- This means that they have an iterator which can be used for STL algorithms.
- There is even couple of specialized utility function to aid in the use
- of the result sets in STL algorithms.
-\layout Standard
-
-The columns in all the dramatic result are also very close to an STL random
- access container.
- However, in addition to accessing the columns by there index number you
- can also access the columns via there field names.
-\layout Standard
-
-In addition, because both the rows and the columns are STL like containers,
- you can also treat the result set as a two- dimensional array.
- For example you can get the 5th item on the 2nd row by simply saying result[2][
-5].
- Because you can also use the field names you can substitute the column
- number by a field name and say result[2]["price"] to get "price" of the
- item on the 2nd row, for example.
-\layout Standard
-
-The actual data that all the dramatic result sets return is stored in a
- special string like class that has some additional magic too it.
- The magic is that the column data will automatically convert itself into
- all of the basic data types as well as some additional types types that
- are designed to handle mysql types which includes types for handling dates,
- times, sets, and types with a null value.
- If there is a problem in the conversion it will either set a warning flag
- or throw an exception depending on how it is configured.
-\layout Standard
-
-The drastic result sets can even be used to help form queries with the help
- of some additional method.
- There is a method for returns: 1) A comma separated list of the data (for
- example: 1.5, 10, "Dog, "Brown"), 2) A comma separated list of the field
- names (for example: age, weight, what, color), and 3) An equal list (for
- example: age = 1.5 AND weight = 10 AND what = "Dog" AND color = "Brown").
-\layout Standard
-
-Mutable result sets can be created with out an actual query so that you
- can take advantage of these methods to aid in inserting data into the database
- with out having to first create an unnecessary query.
-\layout Subsection*
-
-The Static Result Sets
-\layout Standard
-
-The results from an query can also be stored statically in what I call a
- specialized SQL structure.
- These structures are then stored in some STL container such a vector or
- list, or even a set or multi-set as the the specialized structures can
- also be made less-than-comparable.
- Unlike the dramatic result sets it is assumed that the programmer knows
- what the result set is going to look like.
- Because of this all the information about the columns, including the names,
- are lost.
-\layout Standard
-
-These Specialized Structures are exactly that C++ `structs'.
- Each member item is stored with a unique name within the structure.
- You can in no way use STL algorithms or anything else STL to work with
- the individual elements of the structures.
- However naturally because these structures are then stored in STL containers
- you can use STL algorithms on the containers of these structures.
- The containers represent the rows, and the individual elements of the structure
- represent the columns.
- For example you can access the item named "price" on the second row by
- saying result[2].price.
- With the dramatic result set you would have probably needed to say result[2]["p
-rice"] to accomplish the same result.
-\layout Standard
-
-If there is a problem in converting from the result set returned by the
- server to the specialized structures an exception is thrown.
-\layout Standard
-
-To aid in the creating of queries using these specialized structures, the
- same query aiding methods are available to use that are available for the
- dramatic result sets.
- This includes methods for returning a comma separated list of the data,
- a comma separated list of the field names, and an equal list.
-\layout Section*
-
-In addition
-\layout Standard
-
-In addition to the material mentioned there are also many generic classes
- that can be used with other programs.
- Examples of this include a special const string class, a const random access
- adapter that will make a random access container out of a class with nothing
- but the size() method and the subscript ([]) operator defined and a generic
- SQL query class that can be used any SQL C or C++ API.
-\layout Chapter
-
-Important Changes 
-\layout Standard
-
-I will try to keep the changes that will break old code to a minimal however
- when I do I will document them here.
- Once this library goes into alpha testing this section will no longer exist
- as I will try very hard not to make changes that will break old code.
-\layout Section
-
-Current Changes
-\layout Itemize
-
-Changed the syntax of equal_list for SSQLS from 
-\series bold 
-equal_list (cchar *, Manip, cchar *)
-\series default 
- to 
-\series bold 
-equal_list (cchar *, cchar *, Manip)
-\series default 
-.
-\layout Itemize
-
-Mysql++ now runs with egcs.
- But 
-\noun on 
-beware !,
-\noun toggle 
- do not yet use -O6 -mpentium options are still unsafe for g++, with a heavy
- use of constant and static initializers, and especially with C++ exceptions
- .
- Also, please try to keep all objects as local as possible.
- Declare it in the lowest blocks always !!
-\layout Itemize
-
-The 
-\begin_inset Quotes eld
-\end_inset 
-
-connection
-\begin_inset Quotes erd
-\end_inset 
-
- constructors for 
-\series bold 
-Connection
-\series default 
- and 
-\series bold 
-Connection::connect
-\series default 
- (formally known as 
-\series bold 
-Mysql
-\series default 
-) has changed so that the data base name is the first paremeter.
-\layout Itemize
-
-All new client feature implemented in 3.22.xx as various options on connect
- are mplemented in a new constructor and real_connect method
-\layout Itemize
-
-Mysql++ now can be compiled on Win32 with use of Cygwin compiler from Cygnus
- Inc.
-\layout Itemize
-
-Autoconf and Automake are fully implemented
-\layout Itemize
-
-The Specialized SQL Structures (formally known as Custom Mysql Structures)
- changed from mysql_ to sql_.
-\layout Itemize
-
-Changed all of the functions that return zero (false) on success and non-zero
- (true) other wise to bool.
- This means that they now return true on success and false on faillier.
- This means that you now need to negate your expressions that test the output
- of these functions.
- 
-\layout Itemize
-
-Corrected bugs in sql_query.cc regarding delete versus delete[] and string
- length in manip.cc
-\layout Itemize
-
-Almost all methods that returned MysqlString now return a normal string.
- Because 
-\series bold 
-MysqlString
-\series default 
- objects will convert them selves into string when needed there should not
- be a problem with: 
-\begin_deeper 
-\layout LyX-Code
-
-MysqlString s = mysql.host_info
-\end_deeper 
-\layout Itemize
-
-The data type 
-\series bold 
-MysqlRow
-\series default 
- now returns (
-\series bold 
-MysqlString
-\series default 
- or 
-\series bold 
-MysqlColData
-\series default 
-) is now subclassed from a special string class that I wrote to handle working
- with a const string in a much more efficient way (ie it doesn't copy it).
- Unfortunitlly this data type is also more limited see the section on "const_str
-ing" for more info.
-\layout Itemize
-
-All necessary methods pertaining to the administration funcitons have been
- added
-\layout Section
-
-Future Changes
-\layout Itemize
-
-The behavior of MysqlString when used with binary operators is going to
- change in a future version (if I can figure out how to pull it off) Instead
- of converting to the type on the other side of the operator the MysqlString
- will it convert to the type the Mysql server said it originally was.
- This will be a lot safer and more predictable.
-\layout Part*
-
-Usage
-\layout Chapter
-
-Tutorial by Example
-\layout Section
-
-Introduction
-\layout Standard
-
-This tutorial is meant to give you a jump start into using my API.
- My Mysql++ API is a very complicated being with a lot of advance features
- that you can due without if all you want to do is execute simple queries.
-\layout Section
-
-Assumptions
-\layout Standard
-
-This tutorial assumes you know C++ fairly well, inparticuler it assumes
- you know about the Standard Template Library (STL) and exceptions.
-\layout Section
-
-Running the Examples
-\layout Standard
-
-All of the example code form complete running programs.
- However in order to use them you need to first compile them my switching
- to the examples directory and typing in 
-\family typewriter 
-make
-\family default 
-.
- Then you need to set up the database by running reset-db.
- The usage of the reset-db program is as follows.
-\layout LyX-Code
-
-reset-db [host [user [password]]]
-\layout Standard
-
-If you leave off host localhost is assumed.
- If you leave off user your current username is assumed.
- If you leave of the password it is assumed that you don't need one.
-\layout Standard
-
-When you first run the program you need to give it an account with permission
- to create databases.
- Once the database is created you can use any account that has permission
- full permission to the database mysql_cpp_data.
- 
-\layout Standard
-
-You should also run the reset-db program between examples that modify the
- data or else things might not work right.
-\layout Section
-
-The Basics
-\layout Subsection
-
-A Simple Example
-\layout Standard
-
-The following example demonstrates how to open a connection, execute a simple
- query, and display the results.
- The code can be found in the file 
-\family typewriter 
-simple1.cc
-\family default 
- which is located in the examples directory.
-\layout Comment
-
-example:simple1.cc
-\layout LyX-Code-Sans
-
-#include <iostream> 
-\newline 
-#include <iomanip> 
-\newline 
-#include <sqlplus.hh>
-\newline 
-
-\protected_separator 
-
-\newline 
-int main() {
-\newline 
-
-\protected_separator 
- Connection con("mysql_cpp_data");
-\newline 
-
-\protected_separator 
- // The full format for the Connection constructor is
-\newline 
-
-\protected_separator 
- // Connection(cchar *db, cchar *host="", 
-\newline 
-
-\protected_separator 
- //
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cchar *user="", cchar *passwd="") 
-\newline 
-
-\protected_separator 
- // You may need to specify some of them if the database is not on
-\newline 
-
-\protected_separator 
- // the local machine or you database username is not the same as your
-\newline 
-
-\protected_separator 
- // login name, etc..
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
- Query query = con.query();
-\newline 
-
-\protected_separator 
- // This creates a query object that is bound to con.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
- query << "select * from stock";
-\newline 
-
-\protected_separator 
- // You can write to the query object like you would any other ostrem
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
- Result res = query.store();
-\newline 
-
-\protected_separator 
- // Query::store() executes the query and returns the results
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
- cout << "Query: " << query.preview() << endl;
-\newline 
-
-\protected_separator 
- // Query::preview() simply returns a string with the current query
-\newline 
-
-\protected_separator 
- // string in it.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
- cout << "Records Found: " << res.size() << endl << endl;
-\newline 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
- Row row;
-\newline 
-
-\protected_separator 
- cout.setf(ios::left);
-\newline 
-
-\protected_separator 
- cout << setw(17) << "Item" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(4)
-\protected_separator 
- << "Num"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(7)
-\protected_separator 
- << "Weight"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(7)
-\protected_separator 
- << "Price" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << "Date" << endl
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << endl;
-\newline 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
- Result::iterator i;
-\newline 
-
-\protected_separator 
- // The Result class has a read-only Random Access Iterator
-\newline 
-
-\protected_separator 
- for (i = res.begin(); i != res.end(); i++) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row = *i;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw(17) << row[0] 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(4)
-\protected_separator 
- << row[1] 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(7)
-\protected_separator 
- << row["weight"]
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // you can use either the index number or column name when
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // retrieving the colume data as demonstrated above.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(7)
-\protected_separator 
- << row[3]
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << row[4] << endl;
-\newline 
-
-\protected_separator 
- }
-\newline 
-
-\protected_separator 
- return 0;
-\newline 
-}
-\layout Standard
-
-Everything here should be fairly obvious.
- Take particular notice of how I used an iterator with the result set.
-\layout Subsection
-
-A slightly more complicated example
-\layout Standard
-
-This example is almost like the previous one however it uses exceptions
- and the automatic conversion feature of 
-\series bold 
-ColData
-\series default 
-.
- Pay particular notice to how exceptions are used.
- This file for this code is named 
-\family typewriter 
-complic1.cc
-\family default 
-.
-\layout Comment
-
-example:complic1.cc
-\layout LyX-Code-Sans
-
-#include <iostream>
-\newline 
-#include <iomanip>
-\newline 
-#include <sqlplus.hh>
-\newline 
-
-\protected_separator 
-
-\newline 
-int main() {
-\newline 
-
-\protected_separator 
- try { // its in one big try block
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Connection con(use_exceptions);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- con.connect("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // Here I broke making the connection into two calls.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // The first one creates the Connection object with the 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // use exceptions option turned on and the second one
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // makes the connection
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Query query = con.query();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query << "select * from stock";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Result res = query.store();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Query: " << query.preview() << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Records Found: " << res.size() << endl << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Row row;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.setf(ios::left);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw(17) << "Item" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(4)
-\protected_separator 
- << "Num"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(7)
-\protected_separator 
- << "Weight"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(7)
-\protected_separator 
- << "Price" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << "Date" << endl
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << endl;
-\newline 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Result::iterator i;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.precision(3);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- for (i = res.begin(); i != res.end(); i++) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row = *i;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw(17) << row["item"] << setw(4) << row[1] 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(7)
-\protected_separator 
- << (double)row[2]
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// This is converting the row to a double so that we
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// can set the precision of it.
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// ColData has the nice feature that it will convert to
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// any of the basic c++ types.
-\protected_separator 
- if there is a problem
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// in the conversion it will throw an exception (which I 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// cache below).
-\protected_separator 
- To test it try changing the 2 in row[2]
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// to row[0]
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(7) << (double)row[3];
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Date date = row["sdate"]; 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // The ColData is implicitly converted to a date here.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.setf(ios::right);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.fill('0');
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw(2) << date.month << "-" << setw(2) << date.day << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.fill(' ');
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.unsetf(ios::right);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- }
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return 0;
-\newline 
-
-\protected_separator 
- } catch (BadQuery er) { // handle any connection or
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // query errors that may come up
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: " << er.error << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- } catch (BadConversion er) { // handle bad conversions
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: Tried to convert 
-\backslash 
-"" << er.data << "
-\backslash 
-" to a 
-\backslash 
-"" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << er.type_name << "
-\backslash 
-"." << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- }
-\newline 
-}
-\layout Standard
-
-Everything should be fairly obvious.
- A few notes about exceptions, however:
-\layout Enumerate
-
-When the 
-\series bold 
-use_exceptions
-\series default 
- flag is set for a parent object it is also set for all of its children
- the it created after the flag is set.
- For example when the 
-\series bold 
-use_exceptions
-\series default 
- flag is set for the 
-\family typewriter 
-con
-\family default 
- object, it is also set for the 
-\family typewriter 
-query
-\family default 
- object.
- Please note that the 
-\series bold 
-use_exceptions
-\series default 
- flag is not linked, it is copied.
- This means that when you change the 
-\series bold 
-use_exceptions
-\series default 
- flag only its new children are affected, 
-\emph on 
-not
-\emph default 
- the ones it already created.
-\layout Enumerate
-
-
-\series bold 
-ColData
-\series default 
- will always throw an exception when it encounters a bad conversion.
- A bad conversion is defined as a conversion in which: a) All the charters
- from the string are not read in and b) The remaining characters are something
- other than whitespace, zeros (0), or periods (.).
- This means that when ``1.25'' is converted into an int an exception will
- be thrown however not when ``1.00'' is converted into an int as the remaining
- characters are the period and the zero.
- 
-\layout Standard
-
-To see how the exception work try creating an error.
- Some good things to try would be misspelling the table name or changing
- the double to an int.
-\layout Subsection
-
-Getting Info about the Fields
-\layout Standard
-
-The following example demonstrates how to get some basic information about
- the fields, including the name of the field and the SQL type.
- The file is called fieldinfo1.cc.
-\layout Comment
-
-example:fieldinf1.cc
-\layout LyX-Code-Sans
-
-#include <iostream>
-\newline 
-#include <iomanip>
-\newline 
-#include <sqlplus.hh>
-\newline 
-
-\protected_separator 
-
-\newline 
-int main() {
-\newline 
-
-\protected_separator 
- try { // its in one big try block
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Connection con(use_exceptions);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- con.connect("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Query query = con.query();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query << "select * from stock";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Result res = query.store();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Query: " << query.preview() << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Records Found: " << res.size() << endl << endl;
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Query Info:
-\backslash 
-n";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.setf(ios::left);
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- for (unsigned int i = 0; i < res.size(); i++) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw(2)
-\protected_separator 
- << i
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(15) << res.names(i).c_str()
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// this is the name of the field
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(15) << res.types(i).sql_name()
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// this is the SQL identifier name
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// Result::types(unsigned int) returns a mysql_type_info which in many
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// ways is like type_info except that it has additional sql type
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// information in it.
- (with one of the methods being sql_name())
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw(20) << res.types(i).name()
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// this is the C++ identifier name which most closely resembles
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// the sql name (its is implementation defined and often not very readable)
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- }
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- if (res.types(0) == typeid(string))
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Field 'item' is of an sql type which most closely resembles a
-\backslash 
-n"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << "the c++ string type
-\backslash 
-n";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // this is demonstrating how a mysql_type_info can be compared with a c++
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // type_info.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- if (res.types(1) == typeid(short int))
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Field 'num' is of an sql type which most closely resembles a
-\backslash 
-n"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << "the c++ short int type
-\backslash 
-n";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- else if (res.types(1).base_type() == typeid(short int))
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Field 'num' base type is of an sql type which most closely 
-\backslash 
-n"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << "resembles a the c++ short int type
-\backslash 
-n";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // However you have to be careful as if it can be null the actual type
- is 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // Null<TYPE> not TYPE.
-\protected_separator 
- So you should always use the base_type method
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // to get at the underlying type.
-\protected_separator 
- If the type is not null than this base
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // type would be the same as its type.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return 0;
-\newline 
-
-\protected_separator 
- } catch (BadQuery er) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: " << er.error << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- } catch (BadConversion er) { // handle bad conversions
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: Tried to convert 
-\backslash 
-"" << er.data << "
-\backslash 
-" to a 
-\backslash 
-"" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << er.type_name << "
-\backslash 
-"." << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- }
-\newline 
-}
-\newline 
-
-\protected_separator 
-
-\layout Section
-
-Specialized SQL Structures
-\layout Subsection
-
-Retrieving Data
-\layout Standard
-
-The next example demonstrates a fairly interesting concept known as Specialized
- SQL Structures (SSQLS).
- The file name for this code is 
-\family typewriter 
-custom1.cc
-\family default 
-.
-\layout Comment
-
-example:custom1.cc
-\layout LyX-Code-Sans
-
-#include <iostream>
-\newline 
-#include <iomanip>
-\newline 
-#include <vector>
-\newline 
-#include <sqlplus.hh>
-\newline 
-#include <custom.hh>
-\newline 
-
-\protected_separator 
-
-\newline 
-sql_create_5 (stock,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// struct name, 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 1, 5,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// I'll explain these latter
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- string, item,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// type, id
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- int, num,
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- double, weight,
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- double, price,
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Date, sdate)
-\newline 
-
-\protected_separator 
-
-\newline 
-// this is calling a very complex macro which will create a custom
-\newline 
-// struct "stock" which has the variables:
-\newline 
-//
-\protected_separator 
-
-\protected_separator 
- string item
-\newline 
-//
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- int num
-\newline 
-//
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- ...
-\newline 
-//
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Date sdate
-\newline 
-// defined as well methods to help populate the class from a mysql row
-\newline 
-// among other things that I'll get too in a latter example
-\newline 
-
-\protected_separator 
-
-\newline 
-int main () {
-\newline 
-
-\protected_separator 
- try {
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// its in one big try block
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Connection con (use_exceptions);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- con.connect ("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Query query = con.query ();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query << "select * from stock";
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- vector < stock > res;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.storein (res);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // this is storing the results into a vector of the custom struct
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // "stock" which was created my the macro above.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.setf (ios::left);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw (17) << "Item"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (4) << "Num"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (7) << "Weight"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (7) << "Price"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << "Date" << endl
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << endl;
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // Now we we iterate through the vector using an iterator and
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // produce output similar to that using Row
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // Notice how we call the actual variables in i and not an index
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // offset.
-\protected_separator 
- This is because the macro at the begging of the file
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // set up an *actual* struct of type stock which contains the 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // variables item, num, weight, price, and data.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.precision(3);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- vector <stock>::iterator i;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- for (i = res.begin (); i != res.end (); i++) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw (17) << i->item.c_str ()
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// unfortunally the gnu string class does not respond to format
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-// modifers so I have to convert it to a conat char *.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (4) << i->num
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (7) << i->weight
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (7) << i->price
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << i->sdate
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- }
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return 0;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
- } catch (BadQuery er){ // handle any connection 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // or query errors that may come up
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: " << er.error << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
- } catch (BadConversion er) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // we still need to cache bad conversions incase something goes 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // wrong when the data is converted into stock
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: Tried to convert 
-\backslash 
-"" << er.data << "
-\backslash 
-" to a 
-\backslash 
-""
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << er.type_name << "
-\backslash 
-"." << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- }
-\newline 
-}
-\layout Standard
-
-As you can see.
- SSQLS are very powerful things.
-\layout Subsection
-
-Adding Data 
-\layout Standard
-
-SSQLS can also be used to add data to a table.
- The file name for this code is custom2.cc
-\layout Comment
-
-example:custom2.cc
-\layout LyX-Code-Sans
-
-#include <iostream>
-\newline 
-#include <vector>
-\newline 
-#include <sqlplus.hh>
-\newline 
-#include <custom.hh>
-\newline 
-#include "util.hh"
-\newline 
-// util.hh/cc contains the print_stock_table function
-\newline 
-
-\protected_separator 
-
-\newline 
-sql_create_5(stock, 1, 5, string, item, int, num, 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- double, weight, double, price, Date, sdate)
-\newline 
-
-\protected_separator 
-
-\newline 
-int main() {
-\newline 
-
-\protected_separator 
- try { // its in one big try block
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Connection con(use_exceptions);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- con.connect("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Query query = con.query();
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- stock row;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // create an empty stock object
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- /*
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row.item = "Hot Dogs";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row.num = 100;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row.weight = 1.5;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row.price = 1.75;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row.sdate = "1998-09-25"; */
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row.set("Hot Dogs", 100, 1.5, 1.75, "1998-09-25");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // populate stock
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.insert(row);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // form the query to insert the row
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // the table name is the name of the struct by default
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Query : " << query.preview() << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // show the query about to be executed
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.execute();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // execute a query that does not return a result set
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- print_stock_table(query);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // now print the new table;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
- } catch (BadQuery er) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: " << er.error << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- } catch (BadConversion er) { 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: Tried to convert 
-\backslash 
-"" << er.data << "
-\backslash 
-" to a 
-\backslash 
-"" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << er.type_name << "
-\backslash 
-"." << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- }
-\newline 
-}
-\layout Standard
-
-That's all there is to it.
- Because this example modifies the data you should run 
-\family typewriter 
-reset-db
-\family default 
- after running the example code.
-\layout Subsection
-
-Modifying Data 
-\layout Standard
-
-And it almost as easy to modify data with SSQLS.
- The file name is custom3.cc.
-\layout Comment
-
-example:custom3.cc
-\layout LyX-Code-Sans
-
-#include <iostream>
-\newline 
-#include <vector>
-\newline 
-#include <sqlplus.hh>
-\newline 
-#include <custom.hh>
-\newline 
-#include "util.hh"
-\newline 
-// util.hh/cc contains the print_stock_table function
-\newline 
-
-\protected_separator 
-
-\newline 
-sql_create_5(stock, 1, 5, string, item, int, num, 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- double, weight, double, price, Date, sdate)
-\newline 
-
-\protected_separator 
-
-\newline 
-int main() {
-\newline 
-
-\protected_separator 
- try { // its in one big try block
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Connection con(use_exceptions);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- con.connect("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Query query = con.query();
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query << "select * from stock where item = 
-\backslash 
-"Hotdogs' Buns
-\backslash 
-" ";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Result res = query.store();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- if (res.empty()) 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- throw BadQuery("Hotdogs' Buns not found in table, run reset-db");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // here we are testing if the query was successful, if not throw a bad
- query
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- stock row = res[0];
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // because there should only be one row in this query we don't
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // need to use a vector.
-\protected_separator 
- Just store the first row directly in
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // "row".
-\protected_separator 
- We can do this because one of the constructors for
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // stock takes a Row as an parameter.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- stock row2 = row;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // Now we need to create a copy so that the replace query knows
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // what the original values are.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- row.item = "Hotdog Buns"; // now change item
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.update(row2, row);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // form the query to replace the row
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // the table name is the name of the struct by default
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Query : " << query.preview() << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // show the query about to be executed
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.execute();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // execute a query that does not return a result set
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- print_stock_table(query);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // now print the new table;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
- } catch (BadQuery er) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: " << er.error << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- } catch (BadConversion er) { 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: Tried to convert 
-\backslash 
-"" << er.data << "
-\backslash 
-" to a 
-\backslash 
-"" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << er.type_name << "
-\backslash 
-"." << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- }
-\newline 
-}
-\layout Standard
-
-When you run the example you will notice that in the where clause only the
- 
-\emph on 
-item 
-\emph default 
-field is checked for.
- This is because SSQLS also also less-than-comparable.
-\layout Standard
-
-Don't forget to run 
-\family typewriter 
-reset-db
-\family default 
- after running the example.
-\layout Subsection
-
-Less-Than-Comparable
-\layout Standard
-
-SSQLS are can also be made less-than-comparable.
- This means that they can be sorted and stored in sets as demonstrated in
- the next example.
- The file name is custom4.cc
-\layout Comment
-
-example:custom4.cc
-\layout LyX-Code-Sans
-
-#include <iostream>
-\newline 
-#include <iomanip>
-\newline 
-#include <vector>
-\newline 
-#include <sqlplus.hh>
-\newline 
-#include <custom.hh>
-\newline 
-
-\protected_separator 
-
-\newline 
-sql_create_5(stock, 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 1, // This number is used to make a SSQLS less-than-comparable.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // If this number is n then if the first n elements are the 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // same the two SSQLS are the same.
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // In this case if two two stock's "item" are the same then
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // the two stock are the same.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 5, // this number should generally be the same as the number of
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // elements in the list unless you have a good reason not to.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- string,item,
-\protected_separator 
- int,num,
-\protected_separator 
- double,weight,
-\protected_separator 
- double,price,
-\protected_separator 
- Date,sdate)
-\newline 
-
-\protected_separator 
-
-\newline 
-int main() {
-\newline 
-
-\protected_separator 
- try { // its in one big try block
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Connection con(use_exceptions);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- con.connect("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Query query = con.query();
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query << "select * from stock";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- set<stock> res;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.storein(res);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // here we are storing the elements in a set not a vector.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.setf (ios::left);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw (17) << "Item"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (4) << "Num"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (7) << "Weight"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (7) << "Price"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << "Date" << endl
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << endl;
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // Now we we iterate through the set.
-\protected_separator 
- Since it is a set the list will
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // naturally be in order.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- set<stock>::iterator i;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout.precision(3);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- for (i = res.begin (); i != res.end (); i++) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << setw (17) << i->item.c_str ()
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (4) << i->num
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (7) << i->weight
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << setw (7) << i->price
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << i->sdate
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- }
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- i = res.find(stock("Hamburger Buns"));
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- if (i != res.end())
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Hamburger Buns found.
-\protected_separator 
- Currently " << i->num << " in stock.
-\backslash 
-n";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- else
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cout << "Sorry no Hamburger Buns found in stock
-\backslash 
-n";
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // Now we are using the set's find method to find out how many
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // Hamburger Buns are in stock.
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return 0;
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
- } catch (BadQuery er) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: " << er.error << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- } catch (BadConversion er) { 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: Tried to convert 
-\backslash 
-"" << er.data << "
-\backslash 
-" to a 
-\backslash 
-"" 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << er.type_name << "
-\backslash 
-"." << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- }
-\newline 
-}
-\layout Subsection
-
-And There's More
-\layout Standard
-
-This is only scratching the surface of what SSQLS can do for more information
- see the chapter on them (
-\begin_inset LatexCommand \ref{SSQLS}
-
-\end_inset 
-
-).
-\layout Section
-
-Template Queries
-\layout Standard
-
-Another powerful feature of Mysql++ is being able to set up template queries.
- The following example demonstrates how to use them.
- This code is the actual code used to set up and/or reset the sample database.
- It can be found under reset-db.cc.
- I hope to come up with some better examples soon.
-\layout Comment
-
-example:reset-db.cc
-\layout LyX-Code-Sans
-
-#include <iostream>
-\newline 
-#include <sqlplus.hh>
-\newline 
-
-\protected_separator 
-
-\newline 
-int main (int argc, char *argv[]) {
-\newline 
-
-\protected_separator 
- Connection connection(use_exceptions);
-\newline 
-
-\protected_separator 
- try { // the entire main block is one big try block;
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- if (argc == 1) connection.connect("");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- else if (argc == 2) connection.connect("",argv[1]);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- else if (argc == 3) connection.connect("",argv[1],argv[2]);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- else if (argc <= 4) connection.connect("",argv[1],argv[2],argv[3]);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // create a new object and connect based on any (if any) arguments
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // passed to main();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- try {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- connection.select_db("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- } catch (BadQuery er) {
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // if it couldn't connect to the database assume that it doesn't exist
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // and try created it.
-\protected_separator 
- If that does not work exit with an error.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- connection.create_db("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- connection.select_db("mysql_cpp_data");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- }
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- Query query = connection.query();
-\protected_separator 
- // create a new query object
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- try { // ignore any errors here
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // I hope to make this simpler soon
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.execute("drop table stock");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- } catch (BadQuery er) {}
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query << "create table stock
-\protected_separator 
- (item char(20) not null, num smallint,"
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- << "weight double, price double, sdate date)";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.execute(RESET_QUERY);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // send the query to create the table and execute it.
-\protected_separator 
- The
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // RESET_QUERY tells the query object to reset it self after
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // execution
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query << "insert into %5:table values (%0q, %1q, %2, %3, %4q)";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.parse();
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // set up the template query I will use to insert the data.
-\protected_separator 
- The
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // parse method call is important as it is what lets the query
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // know that this is a template and not a literal string
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.def["table"] = "stock";
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // This is setting the parameter named table to stock.
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.execute ("Hamburger Buns", 56, 1.25, 1.1, "1998-04-26");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.execute ("Hotdogs' Buns"
-\protected_separator 
-
-\protected_separator 
- ,65, 1.1 , 1.1, "1998-04-23");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.execute ("Dinner Roles"
-\protected_separator 
- , 75,
-\protected_separator 
- .95, .97, "1998-05-25");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- query.execute ("White Bread"
-\protected_separator 
-
-\protected_separator 
- , 87, 1.5, 1.75, "1998-09-04");
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // The last parameter "table" is not specified here.
-\protected_separator 
- Thus
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- // the default value for "table" is used which is "stock".
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
- } catch (BadQuery er) { // handle any errors that may come up
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- cerr << "Error: " << er.error << endl;
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- return -1;
-\newline 
-
-\protected_separator 
- }
-\newline 
-}
-\newline 
-
-\protected_separator 
-
-\layout Chapter
-
-Class Reference 
-\layout Standard
-
-This chapter documents all of the classes that are meant to be used.
- If it is not documented here 
-\series bold 
-don't use it
-\series default 
- because it is a internal method or class meant to only be used by other
- related classes.
-\layout Comment
-
-Begin Class Ref
-\layout Standard
-
-
-\begin_inset LatexCommand \label{SQLQuery}
-
-\end_inset 
-
-
-\begin_inset LatexCommand \label{SQLQueryParms}
-
-\end_inset 
-
-
-\layout Comment
-
-End Class Ref
-\layout Section
-
-Manipulators 
-\layout Standard
-
-The following manipulators modify only the next item to the right of it
- in an 
-\family typewriter 
-<<
-\family default 
- chain.
- They can be used with any ostream (which includes 
-\series bold 
-SQLQuery
-\series default 
- and 
-\series bold 
-Query
-\series default 
- because they are also ostreams) or 
-\series bold 
-SQLQueryParms
-\series default 
-.
- When used with 
-\series bold 
-SQLQueryParms
-\series default 
- they will override any settings set by the Template Query for that particular
- item.
-\layout Description
-
-quote Quote and escape the next item.
- Can be used with 
-\series bold 
-ostream
-\series default 
- or 
-\series bold 
-SQLQueryParms
-\series default 
-.
- 
-\layout Description
-
-quote_only Quote but don't escape the next item.
- Can be used with 
-\series bold 
-ostream
-\series default 
- or 
-\series bold 
-SQLQueryParms
-\series default 
-.
- 
-\layout Description
-
-quote_only_double Quote, but don't escape the next item, with `` instead
- of '.
- 
-\layout Description
-
-escape Escape the next item.
- 
-\layout Description
-
-do_nothing Does exactly what it says nothing.
- Used as a dummy manipulator when you are required to use some manipulator.
- When used with 
-\series bold 
-SQLQueryParms
-\series default 
- it will make sure that it does not get formatted in any way overriding
- any setting set by the template query.
- 
-\layout Description
-
-ignore Only valid when used with 
-\series bold 
-SQLQueryParms
-\series default 
-.
- Like 
-\series bold 
-do_nothing
-\series default 
- however this one will not override formatting set by the template query,
- thus it is ignored.
- 
-\layout Chapter
-
-Template Queries
-\layout Standard
-
-The idea of template queries is too provide a query with replaceable parameters
- that can be changed between query calls with out having to reform the queries.
-\layout Section
-
-Setting Them Up
-\layout Standard
-
-To set up a template query simply enter the query like it is a normal query.
- For example:
-\layout LyX-Code
-
-query << "select (%2:field1, %3:field2) from stock where %1:wheref = %q0:what"
-\layout Standard
-
-And then execute the Query::parse() method.
- For example:
-\layout LyX-Code
-
-query.parse()
-\layout Section
-
-Template Format
-\begin_inset LatexCommand \label{template format}
-
-\end_inset 
-
-
-\layout Standard
-
-An example template looks like this 
-\layout LyX-Code
-
-select (%2:field1, %3:field2) from stock where %1:wheref = %q0:what
-\layout Standard
-
-The numbers represent the element number in 
-\series bold 
-SQLQueryParms
-\series default 
- (see the next section).
- 
-\layout Standard
-
-The format of the substation parameter is: 
-\layout LyX-Code
-
-%(modifier)##(:name)(:)
-\layout Standard
-
-Where Modifier can be any one of the following:
-\layout Description
-
-% Print an actual "%" 
-\layout Description
-
-"" "" means nothing.
- Don't quote or escape no matter what.
- 
-\layout Description
-
-q This will quote and escape it using mysql_escape_string if it is a string
- or char *, or another Mysql specific types that needs to be quoted.
- 
-\layout Description
-
-Q Quote but don't escape based on the same rules.
- This can save a bit of time if you know the strings will never need quoting
- 
-\layout Description
-
-r Always quote and escape even if it is a number.
- 
-\layout Description
-
-R Always quote but don't escape even if it is a number.
- 
-\layout Standard
-
-## represents a number up to two digits 
-\layout Standard
-
-``:name'' is for an optional name which aids in filling SQLQueryParms.
- Name can contain any alpha-numeric characters or the underscore.
- If you use name it must be proceeded by non-alpha-numeric charter.
- If this is not the case add a column after the name.
- If you need to represent an actual colon after the name follow the name
- by two-columns.
- The first one will end the name and the second one won't be processed.
- 
-\layout Section
-
-Setting the Parameters
-\layout Standard
-
-The parameters can either be set when the query is executed or ahead of
- time by using default parameters.
-\layout Subsection
-
-At Execution Time
-\layout Standard
-
-To specify the parameters when you want to execute a query simply use 
-\series bold 
-Query::store(const SQLString &parm0, [..., const SQLString &parm11])
-\series default 
- (or 
-\series bold 
-Query::use
-\series default 
- or 
-\series bold 
-Query::execute
-\series default 
-).
- Where 
-\series bold 
-parm0
-\series default 
- corresponds to parameter number 0, etc.
- You may specify from 1 to 12 different parameters.
- For example:
-\layout LyX-Code
-
-Result res = query.store("Dinner Roles", "item", "item", "price")
-\layout Standard
-
-with the template query provided in section 
-\begin_inset LatexCommand \ref{template format}
-
-\end_inset 
-
- would produce:
-\layout LyX-Code
-
-select (item, price) from stock where item = "Dinner Roles"
-\layout Standard
-
-The reason for why I 
-\emph on 
-didn't
-\emph default 
- make the template the more logical:
-\layout LyX-Code
-
-select (%0:field1, %1:field2) from stock where %2:wheref = %q3:what
-\layout Standard
-
-will become apparent shortly.
-\layout Subsection
-
-Using Defaults
-\layout Standard
-
-You can also set the parameters one at a time by means of the public data
- member 
-\series bold 
-def
-\series default 
-.
- To change the values of the 
-\series bold 
-def
-\series default 
- simply use the subscript operator.
- You can refer to the parameters either by number or by name.
- For example:
-\layout LyX-Code
-
-query.def[0] = "Dinner Roles";
-\newline 
-query.def[1] = "item";
-\newline 
-query.def[2] = "item";
-\newline 
-query.def[3] = "price";
-\layout Standard
-
-and
-\layout LyX-Code
-
-query.def["what"] = "Dinner Roles";
-\newline 
-query.def["wheref"] = "item";
-\newline 
-query.def["field1"] = "item";
-\newline 
-query.def["field2"] = "price";
-\layout Standard
-
-would both have the same effect.
-\layout Standard
-
-Once all the parameters are set simply execute as you would have executed
- the query before you knew about template queries.
- For example:
-\layout LyX-Code
-
-Result res = query.store()
-\layout Subsection
-
-Combining the Two
-\layout Standard
-
-You can also combine the use of setting the parameters at execution time
- and setting them by use of the 
-\series bold 
-def
-\series default 
- object by simply using the extended form of 
-\series bold 
-Query::store
-\series default 
- (or 
-\series bold 
-use
-\series default 
- or 
-\series bold 
-execute
-\series default 
-) without all of necessary parameters specified.
- For example:
-\layout LyX-Code
-
-query.def["field1"] = "item";
-\newline 
-query.def["field2"] = "price";
-\newline 
-Result res1 = query.store("Hamburger Buns", "item");
-\newline 
-Result res2 = query.store(1.25, "price");
-\layout Standard
-
-Would store the query:
-\layout LyX-Code
-
-select (item, price) from stock where item = "Hamburger Buns"
-\layout Standard
-
-for
-\family typewriter 
- res1 
-\family default 
-and 
-\layout LyX-Code
-
-select (item, price) from stock where price = 1.25
-\layout Standard
-
-for 
-\family typewriter 
-res2
-\family default 
-.
-\layout Standard
-
-Because the extended form of 
-\series bold 
-Query::store
-\series default 
- can only effect the beginning (by number not by location) parameters the
- more logical template query:
-\layout LyX-Code
-
-select (%0:field1, %1:field2) from stock where %2:wheref = %q3:what
-\layout Standard
-
-would 
-\emph on 
-not 
-\emph default 
-of worked in this case.
- Thus the more twisted ordering of
-\layout LyX-Code
-
-select (%2:field1, %3:field2) from stock where %1:wheref = %q0:what
-\layout Standard
-
-was needed so that we can specify 
-\series bold 
-wheref
-\series default 
- and 
-\series bold 
-what
-\series default 
- each time.
-\layout Standard
-
-One thing to watch out for, however, is that 
-\series bold 
-Query::store(const char* q)
-\series default 
- is also defined for executing the query 
-\family typewriter 
-q
-\family default 
-.
- For this reason when you use the 
-\series bold 
-Query::store
-\series default 
- (or 
-\series bold 
-use
-\series default 
-, or 
-\series bold 
-execute
-\series default 
-) with only one item and that item is a 
-\series bold 
-const char*
-\series default 
- you need to explicitly convert it into a SQLString.
- For example:
-\layout LyX-Code
-
-Result res = query.store(SQLString("Hamburger Buns")).
-\layout Subsection
-
-Error Handling
-\layout Standard
-
-If for some reason you did not specify all the parameters when executing
- the query 
-\emph on 
-and
-\emph default 
- the remaining parameters do not have there values set via 
-\family typewriter 
-def
-\family default 
- the query object will throw a 
-\series bold 
-SQLQueryNEParms
-\series default 
- object.
- In which case you you can find out what happened by checking the value
- of 
-\series bold 
-SQLQueryNEParms::string
-\series default 
-.
- 
-\layout Standard
-
-For example:
-\layout LyX-Code
-
-query.def["field1"] = "item";
-\newline 
-query.def["field2"] = "price";
-\newline 
-Result res = query.store(1.25);
-\layout Standard
-
-would throw 
-\series bold 
-SQLQueryNEParms
-\series default 
- because the 
-\family typewriter 
-wheref
-\family default 
- is not specified.
-\layout Standard
-
-In theory this exception should never be thrown.
- If the exception is thrown it probably a logic error on you part.
- (Like in the above example)
-\layout Subsection
-
-More Advanced Stuff
-\layout Standard
-
-To be written.
- However, for now see the class 
-\series bold 
-SQLQuery
-\series default 
- (
-\begin_inset LatexCommand \ref{SQLQuery}
-
-\end_inset 
-
-) and 
-\series bold 
-SQLQueryParms
-\series default 
- (
-\begin_inset LatexCommand \ref{SQLQueryParms}
-
-\end_inset 
-
-) for more information.
-\layout Chapter
-
-Specialized SQL Structures
-\begin_inset LatexCommand \label{SSQLS}
-
-\end_inset 
-
-
-\layout Standard
-
-The Specialized SQL Structures (SSQLS) allows you create structures to hold
- data for mysql queries with extra functionality to make your life easier.
- These structures are in no way related to any Standard Template Library
- (STL) type of containers.
- These structures are exactly that 
-\series bold 
-structs
-\series default 
-.
-  Each member item is stored  with a unique name within the structure.
-  You can in no way use STL algorithms are anything else STL to work with
- the individual structures.
- However you CAN use these structures as the 
-\series bold 
-value_type
-\series default 
- for STL containers.
- (They would be pretty useless if you couldn't.) 
-\layout Section
-
-sql_create_basic 
-\layout Standard
-
-The following command will create a basic mysql query for use with the 
- sample database.
- 
-\layout LyX-Code
-
-sql_create_basic_5(stock,
-\protected_separator 
-0,
-\protected_separator 
-0,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-string,
-\protected_separator 
-item,
-\protected_separator 
-//
-\protected_separator 
-type,
-\protected_separator 
-id,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-int,
-\protected_separator 
-num,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-weight,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-price,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-MysqlDate,
-\protected_separator 
-date)
-\protected_separator 
-
-\layout Standard
-
-This will set up the following structure: 
-\layout LyX-Code
-
-struct
-\protected_separator 
-stock
-\protected_separator 
-{
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock
-\protected_separator 
-()
-\protected_separator 
-{}
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock
-\protected_separator 
-(const MysqlRow
-\protected_separator 
-&row);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-set (const MysqlRow &row);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-string
-\protected_separator 
-item;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-int
-\protected_separator 
-num;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-double
-\protected_separator 
-weight;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-double
-\protected_separator 
-price;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-MysqlDate
-\protected_separator 
-date;
-\protected_separator 
-
-\newline 
-};
-\protected_separator 
-
-\layout Standard
-
-As you can see this is nothing fancy.
-  The main advantage of this simple structure is the 
-\series bold 
-stock (MysqlRow &row)
-\series default 
- constructor which allows you to easily populate a vector of stocks like
- so: 
-\layout LyX-Code
-
-vector<stock>
-\protected_separator 
-result;
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-query.storein(result);
-\protected_separator 
-
-\layout Standard
-
-That's all there is two it.
- The requirements are that the query returns elements in the same order
- as you specified them in the custom structure.
- 
-\layout Standard
-
-The general format is: 
-\layout LyX-Code
-
-sql_create_basic_#(NAME,
-\protected_separator 
-0,
-\protected_separator 
-0,
-\protected_separator 
-TYPE1,
-\protected_separator 
-ITEM1,
-\protected_separator 
-...
-\protected_separator 
-TYPE#,
-\protected_separator 
-ITEM#)
-\protected_separator 
-
-\protected_separator 
-
-\layout Standard
-
-Where # is the number of valuables in the vector, NAME is the name of the
- structure you wish to create, and TYPE1 is the type name for first item
- and ITEM1 is the valuables name for the first item etc..
- 
-\layout Section
-
-sql_create_basic with compare 
-\layout Standard
-
-You can also make the structure comparable by changing the first 0 in the
- previous example to a non zero number.
-  This number, lets call it n, will tell c++ that if the first n number
- or the same then the two structures are the same.
- 
-\layout Standard
-
-For example: 
-\layout LyX-Code
-
-sql_create_basic_5(stock,
-\protected_separator 
-1,
-\protected_separator 
-0,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-string,
-\protected_separator 
-item,
-\protected_separator 
-//
-\protected_separator 
-type,
-\protected_separator 
-id,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-int,
-\protected_separator 
-num,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-weight,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-price,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-MysqlDate,
-\protected_separator 
-date)
-\protected_separator 
-
-\layout Standard
-
-will create a structure where only the item valuable is checked to see if
- two different stocks are the same.
-  It also allows you to compare one structure to another based on the value
- of item.
- (If n is greater than one it will compare the structures in a Lexicographic
- order.
-  For example if it was 2 it would first compare 
-\family typewriter 
-item
-\family default 
- and if item was the same it would  then compare 
-\family typewriter 
-num
-\family default 
-.
-  If num was the same it would declare the two structures the same.) 
-\layout Standard
-
-In addition what the previous example defines it also defines the following:
- 
-\layout LyX-Code
-
-struct
-\protected_separator 
-stock
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-...
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock
-\protected_separator 
-(const
-\protected_separator 
-string
-\protected_separator 
-&p1);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-set (const string &p1);
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-operator
-\protected_separator 
-==
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&other)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-operator
-\protected_separator 
-!=
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&other)
-\protected_separator 
-const;
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-operator
-\protected_separator 
->
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&other)
-\protected_separator 
-const;
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-operator
-\protected_separator 
-<
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&other)
-\protected_separator 
-const;
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-operator
-\protected_separator 
->=
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&other)
-\protected_separator 
-const;
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-operator
-\protected_separator 
-<=
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&other)
-\protected_separator 
-const;
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-int
-\protected_separator 
-cmp
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&other)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-int
-\protected_separator 
-compare
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&other)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-}
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\newline 
-int
-\protected_separator 
-compare
-\protected_separator 
-(const
-\protected_separator 
-stock
-\protected_separator 
-&x,
-\protected_separator 
-const
-\protected_separator 
-stock
-\protected_separator 
-&y);
-\protected_separator 
-
-\layout Standard
-
-int compare (const stock &x, const stock &y) compares x to y and return
- <0 if  x < y, 0 if x = y, and >0 if x > y.
-  stock::cmp and stock::compare are the same thing as compare(*this, other).
- 
-\layout Standard
-
-stock::stock is a constructor that will set item to p1 and leave the other
- variables undefined.
-  This is useful for creating temporary objects to use for comparisons like
- x <= stock("Hotdog").
-   
-\layout Standard
-
-Because 
-\series bold 
-stock
-\series default 
- is now less-then-comparable you can store the query results in a set: 
-\layout LyX-Code
-
-set<stock>
-\protected_separator 
-result;
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-query.storein(result);
-\protected_separator 
-
-\layout Standard
-
-And you can now use it like any other set, for example: 
-\layout LyX-Code
-
-cout
-\protected_separator 
-<<
-\protected_separator 
-result.lower_bound(stock("Hamburger"))->item
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-
-\protected_separator 
-
-\layout Standard
-
-will return the first item that begins with Hamburger.
- 
-\layout Standard
-
-You can also now use it will any STL algorithm that require the values to
- be less-then-comparable.
- 
-\layout Standard
-
-The general format so far is: 
-\layout LyX-Code
-
-sql_create_base_#(NAME,
-\protected_separator 
-CMP,
-\protected_separator 
-0,
-\protected_separator 
-TYPE1,
-\protected_separator 
-ITEM1,
-\protected_separator 
-...
-\protected_separator 
-TYPE#,
-\protected_separator 
-ITEM#)
-\protected_separator 
-
-\protected_separator 
-
-\layout Standard
-
-where CMP is that the number that tells c++ that if the first cmp variables
- are the same then the two structures are the same.
- 
-\layout Section
-
-sql_create_basic with Additional Constructor 
-\layout Standard
-
-The last zero in the last example if for creating another constructor.
- Let this zero be m then it will create a constructor which will populate
- the first n variables.
-  For example: 
-\layout LyX-Code
-
-sql_create_basic_5(stock,
-\protected_separator 
-1,
-\protected_separator 
-5,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-string,
-\protected_separator 
-item,
-\protected_separator 
-//
-\protected_separator 
-type,
-\protected_separator 
-id,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-int,
-\protected_separator 
-num,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-weight,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-price,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-MysqlDate,
-\protected_separator 
-date)
-\protected_separator 
-
-\layout Standard
-
-will also define: 
-\layout LyX-Code
-
-struct
-\protected_separator 
-stock
-\protected_separator 
-{
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-...
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock(const
-\protected_separator 
-string&,
-\protected_separator 
-const
-\protected_separator 
-int&,
-\protected_separator 
-const
-\protected_separator 
-double&,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-const
-\protected_separator 
-double&,
-\protected_separator 
-const
-\protected_separator 
-MysqlDate&);
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-set(const
-\protected_separator 
-string&,
-\protected_separator 
-const
-\protected_separator 
-int&,
-\protected_separator 
-const
-\protected_separator 
-double&,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-const
-\protected_separator 
-double&,
-\protected_separator 
-const
-\protected_separator 
-MysqlDate&);
-\protected_separator 
-
-\newline 
-}
-\protected_separator 
-
-\layout Section
-
-sql_create_basic General Format 
-\layout Standard
-
-Thus the general format for sql_create_basic is 
-\layout LyX-Code
-
-sql_create_basic_#(NAME,
-\protected_separator 
-CMP,
-\protected_separator 
-CNST,
-\protected_separator 
-TYPE1,
-\protected_separator 
-ITEM1,
-\protected_separator 
-...,
-\protected_separator 
-TYPE#,
-\protected_separator 
-ITEM#)
-\protected_separator 
-
-\protected_separator 
-
-\layout Standard
-
-Where: 
-\layout Itemize
-
-# is the number of valuables in the vector 
-\layout Itemize
-
-NAME is the name of the structure you wish to create 
-\layout Itemize
-
-CMP is the number that tells c++, if not set to 0, that if the first cmp
- variables are the same then the two structures are the same.
- 
-\layout Itemize
-
-CNST is the number, if not set to 0, that will create a constructor which
- will populate the first n variables.
- 
-\layout Itemize
-
-TYPE1 is the type name for first item and ITEM1 is the valuables name for
- the first item etc..
- 
-\layout Section
-
-sql_create_basic_c_order 
-\layout Standard
-
-You can also specify an alternate order for when mysql populates the  structure.
- For example: 
-\layout LyX-Code
-
-sql_create_basic_c_order_5(stock,
-\protected_separator 
-2,
-\protected_separator 
-5,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-MysqlDate,
-\protected_separator 
-date,
-\protected_separator 
-5,
-\protected_separator 
-//
-\protected_separator 
-type,
-\protected_separator 
-id,
-\protected_separator 
-order
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
-double,
-\protected_separator 
-price,
-\protected_separator 
-4,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-string,
-\protected_separator 
-item,
-\protected_separator 
-1,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
-
-\protected_separator 
-int,
-\protected_separator 
-num,
-\protected_separator 
-2,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
-double,
-\protected_separator 
-weight,
-\protected_separator 
-3)
-\protected_separator 
-
-\layout Standard
-
-This will create a similar structure as in the previous example except that
- that the order of the data items will be different and c++ will use the
- first two items to compare with (date, price).
-  However because a custom order is specified you can use the same query
- to populate the set.
- It will fill 
-\family typewriter 
-date
-\family default 
- with the first 5th item of the query result set, 
-\family typewriter 
-price
-\family default 
- with the 4th, etc...
- 
-\layout Section
-
-sql_create_basic_c_order General Format 
-\layout Standard
-
-Thus the general format for sql_create_basic is 
-\layout LyX-Code
-
-sql_create_basic_c_order_#
-\protected_separator 
-(NAME,
-\protected_separator 
-CMP,
-\protected_separator 
-CNST,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-TYPE1,
-\protected_separator 
-ITEM1,
-\protected_separator 
-ORDER1,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-...
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-TYPE#,
-\protected_separator 
-ITEM#,
-\protected_separator 
-ORDER#)
-\protected_separator 
-
-\layout Standard
-
-Where: 
-\layout Itemize
-
-# is the number of valuables in the vector 
-\layout Itemize
-
-NAME is the name of the structure you wish to create 
-\layout Itemize
-
-CMP is the number that tells c++, if not set to 0, that if the first cmp
- variables are the same then the two structures are the same.
- 
-\layout Itemize
-
-CNST is the number, if not set to 0, that will create a constructor which
- will populate the first n variables.
- 
-\layout Itemize
-
-TYPE1 is the type name for first item, ITEM1 is the valuable name for the
- first item, ORDER1 is the order number for the first item ...etc...
- 
-\layout Section
-
-sql_create 
-\layout Standard
-
-In addition to the basic structures you can set up enhanced structures that
-  also have methods defined to aid in the creation of queries and in the
- insertion of data in tables.
- 
-\layout Standard
-
-For example: 
-\layout LyX-Code
-
-sql_create_5(stock,
-\protected_separator 
-1,
-\protected_separator 
-5,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-string,
-\protected_separator 
-item,
-\protected_separator 
-//
-\protected_separator 
-type,
-\protected_separator 
-id,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-int,
-\protected_separator 
-num,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-weight,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-price,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-MysqlDate,
-\protected_separator 
-date)
-\protected_separator 
-
-\layout Standard
-
-which will, in addition to that which is defined in sql_create_basic with
- Additional Constructor, define the equivalent to: 
-\layout LyX-Code
-
-struct
-\protected_separator 
-stock
-\protected_separator 
-{
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-...
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-static
-\protected_separator 
-char
-\protected_separator 
-*names[];
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-static
-\protected_separator 
-char
-\protected_separator 
-*table;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-template
-\protected_separator 
-<class
-\protected_separator 
-Manip>
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock_value_list<Manip>
-\protected_separator 
-value_list(cchar
-\protected_separator 
-*d
-\protected_separator 
-=
-\protected_separator 
-",",
-\protected_separator 
-
-\protected_separator 
-//
-\protected_separator 
-basic
-\protected_separator 
-form
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-Manip
-\protected_separator 
-m
-\protected_separator 
-=
-\protected_separator 
-mysql_quote)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-template
-\protected_separator 
-<class
-\protected_separator 
-Manip>
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock_field_list<Manip>
-\protected_separator 
-field_list(cchar
-\protected_separator 
-*d
-\protected_separator 
-=
-\protected_separator 
-",",
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-Manip
-\protected_separator 
-m
-\protected_separator 
-=
-\protected_separator 
-mysql_do_nothing)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-template
-\protected_separator 
-<class
-\protected_separator 
-Manip>
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock_equal_list<Manip>
-\protected_separator 
-equal_list(cchar
-\protected_separator 
-*d
-\protected_separator 
-=
-\protected_separator 
-",",
-\layout LyX-Code
-
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-cchar *e = " = ",
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-Manip
-\protected_separator 
-m
-\protected_separator 
-=
-\protected_separator 
-mysql_quote,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-template
-\protected_separator 
-<class
-\protected_separator 
-Manip>
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-//
-\protected_separator 
-bool
-\protected_separator 
-form
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock_cus_value_list<Manip>
-\protected_separator 
-value_list([cchar
-\protected_separator 
-*d,
-\protected_separator 
-[Manip
-\protected_separator 
-m,]
-\protected_separator 
-]
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-i1,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-i2
-\protected_separator 
-=
-\protected_separator 
-false,
-\protected_separator 
-...
-\protected_separator 
-,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-bool
-\protected_separator 
-i5
-\protected_separator 
-=
-\protected_separator 
-false)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-template
-\protected_separator 
-<class
-\protected_separator 
-Manip>
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-//
-\protected_separator 
-list
-\protected_separator 
-form
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock_cus_value_list<Manip>
-\protected_separator 
-value_list([cchar
-\protected_separator 
-*d,
-\protected_separator 
-[Manip
-\protected_separator 
-m,]
-\protected_separator 
-]
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-stock_enum
-\protected_separator 
-i1,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-stock_enum
-\protected_separator 
-i2
-\protected_separator 
-=
-\protected_separator 
-stock_NULL,
-\protected_separator 
-...,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-stock_enum
-\protected_separator 
-i5
-\protected_separator 
-=
-\protected_separator 
-stock_NULL)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-template
-\protected_separator 
-<class
-\protected_separator 
-Manip>
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-//
-\protected_separator 
-vector
-\protected_separator 
-form
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-stock_cus_value_list<Manip>
-\protected_separator 
-value_list([cchar
-\protected_separator 
-*d,
-\protected_separator 
-[Manip
-\protected_separator 
-m,]
-\protected_separator 
-]
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-vector<bool>
-\protected_separator 
-*i)
-\protected_separator 
-const;
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-...(The
-\protected_separator 
-logical
-\protected_separator 
-equivalent
-\protected_separator 
-for
-\protected_separator 
-field_list
-\protected_separator 
-and
-\protected_separator 
-equal_list)...
-\protected_separator 
-
-\newline 
-};
-\protected_separator 
-
-\layout Standard
-
-
-\series bold 
-value_list()
-\series default 
- returns a special class that when used with the << operator with an ostream
- on the left will return a comma separated list with values properly quoted
- and escaped when needed.
- 
-\layout Standard
-
-
-\series bold 
-field_list()
-\series default 
- return a special class than does the same thing but returns  a list of
- fields that the structure holds which in this case is the same thing as
- the valuable names.
-  The field names are not escaped or quoted 
-\layout Standard
-
-
-\series bold 
-equal_list()
-\series default 
- returns a comma separated list with the format  
-\series bold 
-field name = value
-\series default 
-.
- The field name is not quoted or escaped and value is escaped or quoted
- as needed.
- 
-\layout Standard
-
-For example: 
-\layout LyX-Code
-
-stock
-\protected_separator 
-s("Dinner
-\protected_separator 
-Roles",75,0.95,0.97,"1998-05-25");
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-cout
-\protected_separator 
-<<
-\protected_separator 
-"Value
-\protected_separator 
-List:
-\protected_separator 
-"
-\protected_separator 
-<<
-\protected_separator 
-s.comma_list()
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-
-\newline 
-cout
-\protected_separator 
-<<
-\protected_separator 
-"Field
-\protected_separator 
-List:
-\protected_separator 
-"
-\protected_separator 
-<<
-\protected_separator 
-s.field_list()
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-
-\newline 
-cout
-\protected_separator 
-<<
-\protected_separator 
-"Equal
-\protected_separator 
-List:
-\protected_separator 
-"
-\protected_separator 
-<<
-\protected_separator 
-s.equal_list()
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-
-\layout Standard
-
-Would return something like (with a little extra hand formating): 
-\layout LyX-Code
-
-Value
-\protected_separator 
-List:
-\protected_separator 
-'Dinner
-\protected_separator 
-Roles',75,0.95,0.97,'1998-05-25'
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-Field
-\protected_separator 
-List:
-\protected_separator 
-item,num,weight,price,date
-\protected_separator 
-
-\newline 
-Equal
-\protected_separator 
-List:
-\protected_separator 
-item
-\protected_separator 
-=
-\protected_separator 
-'Dinner
-\protected_separator 
-Roles',num
-\protected_separator 
-=
-\protected_separator 
-75,weight
-\protected_separator 
-=
-\protected_separator 
-0.95,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-price
-\protected_separator 
-=
-\protected_separator 
-0.97,date
-\protected_separator 
-=
-\protected_separator 
-'1998-05-25'
-\protected_separator 
-
-\layout Standard
-
-A combination of the field and value list can be used for insert or replace
- queries.
-  For example: 
-\layout LyX-Code
-
-query
-\protected_separator 
-<<
-\protected_separator 
-"insert
-\protected_separator 
-into
-\protected_separator 
-stock
-\protected_separator 
-("
-\protected_separator 
-<<
-\protected_separator 
-s.field_list()
-\protected_separator 
-")
-\protected_separator 
-values
-\protected_separator 
-"
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-<<
-\protected_separator 
-s.value_list();
-\protected_separator 
-
-\layout Standard
-
-will insert 
-\family typewriter 
-s
-\family default 
- into table stock.
- 
-\layout Standard
-
-You can also use SQLQuery::insert or SQLQuery::replace (and thus Query::insert
- or Query::replace) as a short cut to accomplish the same task like so:
- 
-\layout LyX-Code
-
-query.insert(s);
-\layout Standard
-
-It will use s.table for the table name which defaults to the name of the
- structure.
- 
-\layout Standard
-
-You can also specify an different delimiter "d".
-  If none is specified it defaults to ",".
-  With this you can use the delimiter " AND " for equal_list to aid in update
- and select queries.
-  For example: 
-\layout LyX-Code
-
-stock
-\protected_separator 
-s2
-\protected_separator 
-=
-\protected_separator 
-s;
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-s2.item
-\protected_separator 
-=
-\protected_separator 
-"6
-\protected_separator 
-Dinner
-\protected_separator 
-Roles";
-\protected_separator 
-
-\newline 
-query
-\protected_separator 
-<<
-\protected_separator 
-"UPDATE
-\protected_separator 
-TABLE
-\protected_separator 
-stock
-\protected_separator 
-SET
-\protected_separator 
-"
-\protected_separator 
-<<
-\protected_separator 
-s2.equal_list()
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-<<
-\protected_separator 
-"
-\protected_separator 
-WHERE
-\protected_separator 
-"
-\protected_separator 
-<<
-\protected_separator 
-s.equal_list("
-\protected_separator 
-AND
-\protected_separator 
-");
-\protected_separator 
-
-\layout Standard
-
-would produce the query: 
-\layout LyX-Code
-
-UPDATE
-\protected_separator 
-TABLE
-\protected_separator 
-stock
-\protected_separator 
-SET
-\protected_separator 
-item
-\protected_separator 
-=
-\protected_separator 
-'6
-\protected_separator 
-Dinner
-\protected_separator 
-Roles',num
-\protected_separator 
-=
-\protected_separator 
-75,weight
-\protected_separator 
-=
-\protected_separator 
-0.95,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-price
-\protected_separator 
-=
-\protected_separator 
-0.97,date
-\protected_separator 
-=
-\protected_separator 
-'1998-05-25'
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-WHERE
-\protected_separator 
-item
-\protected_separator 
-=
-\protected_separator 
-'Dinner
-\protected_separator 
-Roles'
-\protected_separator 
-AND
-\protected_separator 
-num
-\protected_separator 
-=
-\protected_separator 
-75
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-AND
-\protected_separator 
-weight
-\protected_separator 
-=
-\protected_separator 
-0.95
-\protected_separator 
-AND
-\protected_separator 
-price
-\protected_separator 
-=
-\protected_separator 
-0.97
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-AND
-\protected_separator 
-date
-\protected_separator 
-=
-\protected_separator 
-'1998-05-25'
-\protected_separator 
-
-\layout Standard
-
-which will change the entree in the table so that item is now "6 Dinner
- Roles" instead of "Dinner Roles" 
-\layout Standard
-
-You can use 
-\series bold 
-SQLQuery::update
-\series default 
- (and thus 
-\series bold 
-Query::update
-\series default 
-) as a short cut to accomplishing the same task like so: 
-\layout LyX-Code
-
-stock
-\protected_separator 
-s2
-\protected_separator 
-=
-\protected_separator 
-s;
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-s2.item
-\protected_separator 
-=
-\protected_separator 
-"6
-\protected_separator 
-Dinner
-\protected_separator 
-Roles";
-\protected_separator 
-
-\newline 
-query.update(s,s2);
-\protected_separator 
-
-\layout Standard
-
-Like 
-\series bold 
-SQLQuery::insert
-\series default 
-, it will use s.table for the table name which defaults to the name of the
- structure.
- 
-\layout Standard
-
-You can also specify an different manipulator which will effect the way
- c++ quotes or escapes the values.
-  This may be any valid stream manipulator that only effects the item to
- the right of manipulator.
- 
-\series bold 
-value_list
-\series default 
- and 
-\series bold 
-equal_list
-\series default 
- defaults to 
-\series bold 
-escape
-\series default 
- and 
-\series bold 
-field_list
-\series default 
- defaults to 
-\series bold 
-do_nothing
-\series default 
-.
-  For 
-\series bold 
-equal_list
-\series default 
- the manipulator only effects the 
-\series bold 
-value
-\series default 
- part and not the 
-\series bold 
-field name
-\series default 
- part.
- 
-\layout Standard
-
-This can be useful creating exporting to a file where you don't want quotes
- around strings for example.
- 
-\layout LyX-Code
-
-table_out
-\protected_separator 
-<<
-\protected_separator 
-q.value_list("
-\backslash 
-
-\protected_separator 
-t",
-\protected_separator 
-mysql_escape)
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\layout Standard
-
-will append data to the file handle table_out.
- 
-\layout Standard
-
-The three non-basic forms allow you to specify which items are returned.
- For example: 
-\layout LyX-Code
-
-cout
-\protected_separator 
-<<
-\protected_separator 
-q.value_list(false,false,true,true,false)
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-//bool
-\protected_separator 
-form
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-cout
-\protected_separator 
-<<
-\protected_separator 
-q.value_list(stock_weight,
-\protected_separator 
-stock_price)
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-//list
-\protected_separator 
-form
-\protected_separator 
-
-\layout Standard
-
-will both return: 
-\layout LyX-Code
-
-0.95,0.97
-\protected_separator 
-
-\protected_separator 
-
-\layout Standard
-
-The 
-\shape italic 
-bool form
-\shape default 
- excepts boolean arguments where each true/false represents an wether to
- show a valuable.
-  False means not to show it while true means  to show it.
- If you leave of some they are assumed to be false.
-  For example: 
-\layout LyX-Code
-
-cout
-\protected_separator 
-<<
-\protected_separator 
-q.value_list(false,false,true,true)
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-
-\protected_separator 
-
-\layout Standard
-
-is the same as the above example.
-   
-\layout Standard
-
-The 
-\shape italic 
-list form
-\shape default 
- allows you to specify which items to show.
-  An enum values are created for each valuable with the name of struct plus
- the underscore character prefixed before it.
-  For example:  item becomes stock_item.
- 
-\layout Standard
-
-These forms can be useful is select queries.
-  For example: 
-\layout LyX-Code
-
-query
-\protected_separator 
-<<
-\protected_separator 
-"SELECT
-\protected_separator 
-*
-\protected_separator 
-FROM
-\protected_separator 
-stock
-\protected_separator 
-WHERE
-\protected_separator 
-"
-\protected_separator 
-
-\layout LyX-Code
-
-
-\protected_separator 
- 
-\protected_separator 
- 
-\protected_separator 
- <<
-\protected_separator 
-q.equal_list("
-\protected_separator 
-AND
-\protected_separator 
-",stock_weight,stock_price);
-\protected_separator 
-
-\layout Standard
-
-would produce the query: 
-\layout LyX-Code
-
-SELECT
-\protected_separator 
-*
-\protected_separator 
-FROM
-\protected_separator 
-stock
-\protected_separator 
-WHERE
-\protected_separator 
-weight=0.95
-\protected_separator 
-AND
-\protected_separator 
-price=0.97
-\protected_separator 
-
-\protected_separator 
-
-\layout Standard
-
-which will select all rows from stock which have the same weight and price
- as 
-\shape italic 
-q
-\shape default 
-.
- 
-\layout Standard
-
-The 
-\shape italic 
-vector form
-\shape default 
- (not shown above) allows you to pass a boolean vector which is a time saver
- if you use the some pattern more than once as it avoids having to create
- the vector from the arguments each time.
-  If 
-\family typewriter 
-a
-\family default 
- is a boolean vector then 
-\family typewriter 
-a[0]
-\family default 
- will hold wether to include the first variable 
-\family typewriter 
-a[1]
-\family default 
- the second etc...
-  For example: 
-\layout LyX-Code
-
-vector<bool>
-\protected_separator 
-a;
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-a[0]
-\protected_separator 
-=
-\protected_separator 
-false;
-\protected_separator 
-a[1]
-\protected_separator 
-=
-\protected_separator 
-false;
-\protected_separator 
-a[2]
-\protected_separator 
-=
-\protected_separator 
-true;
-\protected_separator 
-a[3]
-\protected_separator 
-=
-\protected_separator 
-true;
-\protected_separator 
-a[4]
-\protected_separator 
-=
-\protected_separator 
-false;
-\protected_separator 
-
-\newline 
-query
-\protected_separator 
-<<
-\protected_separator 
-"SELECT
-\protected_separator 
-*
-\protected_separator 
-FROM
-\protected_separator 
-stock
-\protected_separator 
-WHERE
-\protected_separator 
-"
-\protected_separator 
-<<
-\protected_separator 
-q.equal_list("
-\protected_separator 
-AND
-\protected_separator 
-",
-\protected_separator 
-a);
-\protected_separator 
-
-\layout Standard
-
-will produce the same query as in the above example.
- 
-\layout Section
-
-sql_create_c_names 
-\layout Standard
-
-You can also specify alternate field names like so: 
-\layout LyX-Code
-
-sql_create_c_names_5(stock,
-\protected_separator 
-1,
-\protected_separator 
-5,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-string,
-\protected_separator 
-item,
-\protected_separator 
-"item",
-\protected_separator 
-//
-\protected_separator 
-type,
-\protected_separator 
-id,
-\protected_separator 
-column
-\protected_separator 
-name
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-int,
-\protected_separator 
-num,
-\protected_separator 
-"quantity",
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-weight,
-\protected_separator 
-"weight",
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-double,
-\protected_separator 
-price,
-\protected_separator 
-"price"
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-MysqlDate,
-\protected_separator 
-date,
-\protected_separator 
-"shipment")
-\protected_separator 
-
-\layout Standard
-
-When 
-\series bold 
-field_list
-\series default 
- or 
-\series bold 
-equal_list
-\series default 
- is used it will use the given  field names rather than the variable names
- for example: 
-\layout LyX-Code
-
-stock
-\protected_separator 
-s("Dinner
-\protected_separator 
-Roles",75,0.95,0.97,"1998-05-25");
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-cout
-\protected_separator 
-<<
-\protected_separator 
-"Field
-\protected_separator 
-List:
-\protected_separator 
-"
-\protected_separator 
-<<
-\protected_separator 
-s.field_list()
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-
-\newline 
-cout
-\protected_separator 
-<<
-\protected_separator 
-"Equal
-\protected_separator 
-List:
-\protected_separator 
-"
-\protected_separator 
-<<
-\protected_separator 
-s.equal_list()
-\protected_separator 
-<<
-\protected_separator 
-endl;
-\protected_separator 
-
-\layout Standard
-
-Would return something like (with a little extra hand formating): 
-\layout LyX-Code
-
-Field
-\protected_separator 
-List:
-\protected_separator 
-item,quantity,weight,price,shipment
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-Equal
-\protected_separator 
-List:
-\protected_separator 
-item
-\protected_separator 
-=
-\protected_separator 
-'Dinner
-\protected_separator 
-Roles',quantity
-\protected_separator 
-=
-\protected_separator 
-75,weight
-\protected_separator 
-=
-\protected_separator 
-0.95,
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-price
-\protected_separator 
-=
-\protected_separator 
-0.97,shipment
-\protected_separator 
-=
-\protected_separator 
-'1998-05-25'
-\protected_separator 
-
-\layout Section
-
-sql_create_c_names General Format 
-\layout Standard
-
-The general format is: 
-\layout LyX-Code
-
-sql_create_c_names_#
-\protected_separator 
-(NAME,
-\protected_separator 
-CMP,
-\protected_separator 
-CNST,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-TYPE1,
-\protected_separator 
-ITEM1,
-\protected_separator 
-NAME1,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-...
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-TYPE#,
-\protected_separator 
-ITEM#,
-\protected_separator 
-NAME#)
-\protected_separator 
-
-\layout Standard
-
-where NAME1 is the name of the first field, etc.
-  Everything else is the same as it is the same as in sql_create_basic_c_order
- General Format.
- 
-\layout Section
-
-sql_create_c_order 
-\layout Standard
-
-As in sql_create_basic_c_order you may specify a custom order.
- The general from is: 
-\layout LyX-Code
-
-sql_create_c_order_#
-\protected_separator 
-(NAME,
-\protected_separator 
-CMP,
-\protected_separator 
-CNST,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-TYPE1,
-\protected_separator 
-ITEM1,
-\protected_separator 
-ORDER1,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-...
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-TYPE#,
-\protected_separator 
-ITEM#,
-\protected_separator 
-ORDER#)
-\protected_separator 
-
-\layout Standard
-
-where everything is the same as in  sql_create_basic_c_order General Format.
- 
-\layout Section
-
-sql_create_complete 
-\layout Standard
-
-You can also specify both a custom order and custom field names.
-   The general from is.
- 
-\layout LyX-Code
-
-sql_create_complete_#
-\protected_separator 
-(NAME,
-\protected_separator 
-CMP,
-\protected_separator 
-CNST,
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-TYPE1,
-\protected_separator 
-ITEM1,
-\protected_separator 
-NAME1,
-\protected_separator 
-ORDER1,
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-...
-\protected_separator 
-
-\protected_separator 
-
-\newline 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-
-\protected_separator 
-TYPE#,
-\protected_separator 
-ITEM#,
-\protected_separator 
-NAME#,
-\protected_separator 
-ORDER#)
-\protected_separator 
-
-\layout Standard
-
-Where everything is the same as in  sql_create_c_order General Format and
- sql_create_c_names General Format.
- 
-\layout Section
-
-Changing the table name 
-\layout Standard
-
-In order to avoid having even more forms I decided not to allow you to specify
- a different table name in the actual macro call.
- The table name is used by 
-\series bold 
-SQLQuery::insert
-\series default 
-, 
-\series bold 
-replace
-\series default 
-, and 
-\series bold 
-update
-\series default 
-.
-  However you can easeally change the default table name, which is the same
- as the struct name, by changing the reference 
-\series bold 
-NAME::table()
-\series default 
- returns to a different 
-\series bold 
-const char *
-\series default 
-  For example: 
-\layout LyX-Code
-
-stock::table()
-\protected_separator 
-=
-\protected_separator 
-"in_stock"
-\protected_separator 
-
-\protected_separator 
-
-\layout Standard
-
-Will change the table name to "in_stock" in the examples used through out
- this guide.
- 
-\layout Section
-
-Seeing the actual code 
-\layout Standard
-
-To see the actual code that the macro inserts use sql++pretty.
-  For example: 
-\layout LyX-Code
-
-sql++pretty
-\protected_separator 
-<
-\protected_separator 
-test.cc
-\protected_separator 
-|
-\protected_separator 
-less
-\protected_separator 
-
-\protected_separator 
-
-\layout Section
-
-Adding functionality 
-\layout Standard
-
-The best way to add functionality is through inheritance.
-  Even though you could paste the code outputted from pretty.pl and modify
- it this is not recommended because it won't reflect future enhancements.
- 
-\layout Section
-
-Other notes 
-\layout Standard
-
-Macros are defined for structures with up to 25 items.
-  If you need more  modify the underlying perl script custom.pl.
- This perl script is used to generate the header file.
- It in no way tries to parse C++ code.
- 
-\layout Standard
-
-The header file that the script custom.pl creates is close to a meg.
- However, please note that the 1 meg header file (custom-macros.hh) is NOTHING
- but macros.
-  Therefor the compiler has to do very little work when reading is.
- 
-\layout Standard
-
-Also, everything included by the macro call is done in such a way that you
- can safely include the macro call in a header file and not have to worry
- about duplicate function calls or anything of the like.
- 
-\layout Chapter
-
-Long Names
-\layout Standard
-
-By default the Mysql++ API uses both short names with out the
-\series bold 
- Mysql
-\series default 
- or 
-\series bold 
-mysql_ 
-\series default 
-prefix and long names with the 
-\series bold 
-Mysql
-\series default 
- or 
-\series bold 
-mysql_ 
-\series default 
-prefix.
- If this causes name problems define the macro 
-\series bold 
-MYSQL_NO_SHORT_NAMES
-\series default 
- before including 
-\series bold 
-mysql++
-\series default 
-.
- This will force the use of long names only.
- The short and long names are mapped as follows:
-\layout Standard
-\added_space_top 0.3cm \added_space_bottom 0.3cm \align center \LyXTable
-multicol5
-33 2 0 0 -1 -1 -1 -1
-1 1 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-1 0 0 0
-2 1 0 "" ""
-2 1 1 "" ""
-1 8 1 1 0 0 0 "" ""
-1 8 1 1 0 0 0 "" ""
-0 2 1 0 0 0 0 "" ""
-0 2 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-0 8 1 0 0 0 0 "" ""
-
-
-\series bold 
-Short Name
-\newline 
-Long Name
-\series default 
-
-\newline 
-BadQuery
-\newline 
-MysqlBadQuery
-\newline 
-Connection
-\newline 
-MysqlConnection
-\newline 
-ResNSel
-\newline 
-ResNSel
-\newline 
-ResUse 
-\newline 
-ResUse MysqlResUse
-\newline 
-Result 
-\newline 
-MysqlRes
-\newline 
-Field
-\newline 
-MysqlField
-\newline 
-Fields
-\newline 
-MysqlFields
-\newline 
-ResIter 
-\newline 
-MysqlResIter
-\newline 
-ResultIter 
-\newline 
-MysqlResIter
-\newline 
-Row 
-\newline 
-MysqlRow
-\newline 
-MutableRow 
-\newline 
-MysqlMutableRow
-\newline 
-FieldNames 
-\newline 
-MysqlFieldNames
-\newline 
-Query
-\newline 
-MysqlQuery
-\newline 
-BadConversion 
-\newline 
-MysqlBadConversion 
-\newline 
-ColData 
-\newline 
-MysqlColData 
-\newline 
-MutableColData
-\newline 
-MysqlMutableColData
-\newline 
-quote
-\newline 
-mysql_quote
-\newline 
-quote_only
-\newline 
-mysql_quote_only
-\newline 
-quote_double_only
-\newline 
-mysql_quote_double_only
-\newline 
-escape
-\newline 
-mysql_escape
-\newline 
-do_nothing 
-\newline 
-mysql_do_nothing 
-\newline 
-ignore
-\newline 
-mysql_ignore
-\newline 
-Date
-\newline 
-MysqDate
-\newline 
-Time
-\newline 
-MysqlTime
-\newline 
-DateTime
-\newline 
-MysqlDateTime
-\newline 
-Set
-\newline 
-MysqlSet
-\newline 
-Null
-\newline 
-MysqlNull
-\newline 
-null_type 
-\newline 
-mysql_null_type
-\newline 
-null 
-\newline 
-mysql_null
-\newline 
-NullisNull
-\newline 
-MysqlNullisNull
-\newline 
-NullisZero
-\newline 
-MysqlNullisZero
-\newline 
-NullisBlank
-\newline 
-MysqlNullisBlank
-\layout Part*
-
-Appendices
-\layout LaTeX
-
-
-\backslash 
-appendix
-\layout Chapter
-
-Changelog
-\layout Section*
-
-1.4 (Nov 25 1999) Sinisa Milivojevic <sinisa@cytanet.com.cy>
-\layout Itemize
-
-Fixed bug in store and storein methods
-\layout Itemize
-
-Fixed one serious memory leak
-\layout Itemize
-
-Fixed a very serious bug generated by gcc 2.95.xx !!
-\layout Itemize
-
-Added robustness in classes, so that e.g.
- same query and row objects can be re-used
-\layout Itemize
-
-Changed sinisa_ex example to reflect and demonstrate this stability
-\layout Itemize
-
-Changed Changelog and README
-\layout Itemize
-
-Few other bug fixes and small improvements and speed-ups
-\layout Section*
-
-1.3 (Nov 10 1999) Sinisa Milivojevic <sinisa@cytanet.com.cy>
-\layout Itemize
-
-Fixed several erronous definitions
-\layout Itemize
-
-Further changed source to be 2.95.2 compatible
-\layout Itemize
-
-Expunged unused statements, especially dubious ones, like use of pointer_tracker
-\layout Itemize
-
-Corrected bug in example file fieldinf1
-\layout Itemize
-
-Finally fixed mysql_init in Connection constructor, which provided much
- greater stability !
-\layout Itemize
-
-Added read and get options, so that clients, like mysqlgui can use it
-\layout Itemize
-
-Changed Changelog and README
-\layout Itemize
-
-Many other bug fixes.
-\layout Section*
-
-1.2 (Oct 15 1999) Sinisa Milivojevic <sinisa@cytanet.com.cy>
-\layout Itemize
-
-First offical release.
- Version 1.0 and 1.1 were releases by Sinisa before I (Kevin Atkinson) made
- him the offical maintainer,
-\layout Itemize
-
-Many manual fixes.
-\layout Itemize
-
-Changed README and Changelog
-\layout Itemize
-
-Changed source to be compilable by gcc 2.95.xx, tribute to Kevin Atkinson
- <kevinatk@home.com>
-\layout Itemize
-
-Added methods in Connection class which are necessary for fullfilling administra
-tive functions with MySQL
-\layout Itemize
-
-Added many bug fixes in code pertaining to missing class initializers ,
- as notified by Michael Rendell <michael@cs.mun.ca>
-\layout Itemize
-
-Sinisa Milivojevic <sinisa@cytanet.com.cy> is now the offical maintainer.
-\layout Section*
-
-1.1 (Aug 2 1999) Sinisa Milivojevic <sinisa@cytanet.com.cy>
-\layout Itemize
-
-Added several bug fixes
-\layout Itemize
-
-Fixed memory leak problems and variables overlapping problems.
-\layout Itemize
-
-Added automake and autoconf support by loic@ceic.com
-\layout Itemize
-
-Added Makefile for manual
-\layout Itemize
-
-Added support for cygwin
-\layout Itemize
-
-Added example sinisa_ex (let modesty prevail) which used to crash a lot
- when memory allocation, memory leak and overlap problems were present.
- Smooth running of this example proves that all those bugs are fixed 
-\layout Itemize
-
-Corrected bugs in sql_query.cc regarding delete versus delete[] and string
- length in manip.cc
-\layout Itemize
-
-Changed manual
-\layout Itemize
-
-Changed README
-\layout Itemize
-
-Many other smaller things
-\layout Section*
-
-1.0 (June 9 1999) Michael Widenius <monty@monty.pp.sci.fi>
-\layout Itemize
-
-Added patches from Orion Poplawski <orion@bvt.com> to support the UnixWare
- 7.0 compiler
-\layout Section*
-
-.64.1.1a (Sep 27 1998)
-\layout Itemize
-
-Fixed several bugs that caused my library to fail to compile with egcs 1.1.
- Hopefully it will still compile with egcs 1.0 however I have not been able
- to test it with egcs 1.0.
-\layout Itemize
-
-Removed some problem causing debug output in sql++pretty.
-\layout Section*
-
-.64.1a (Aug 1 1998)
-\layout Itemize
-
-Added an (almost) full guide to using Template Queries.
-\layout Itemize
-
-Fixed it so the SQLQuery will throw an exception when all the template parameter
-s are not provided.
-\layout Itemize
-
-Proofread and speedchecked the manual (it really needed it).
-\layout Itemize
-
-Other minor document fixes.
-\layout Section*
-
-.64.0.1a (July 31 1998) 
-\layout Itemize
-
-Reworked the Class Reference section a bit.
-\layout Itemize
-
-Minor document fixes
-\layout Itemize
-
-Added more examples for SSQLS.
-\layout Itemize
-
-Changed the syntax of equal_list for SSQLS from equal_list (cchar *, Manip,
- cchar *) to (cchar *, cchar *, Manip).
-\layout Itemize
-
-Added set methods to SSQLS.
- These new methods do the same thing as there corresponding constructors.
-\layout Itemize
-
-Added methods for creating a mysql_type_info from a C++ type_info.
-\layout Section*
-
-.64.a (July 24 1998)
-\layout Itemize
-
-Changed the names of all the classes so they no longer have to have Mysql
- in the begging of it.
- However if this creates a problem you can define a macro to 
-\emph on 
-only
-\emph default 
- use the old names instead.
- 
-\layout Itemize
-
-The Specialized SQL Structures (formally known as Custom Mysql Structures)
- changed from mysql_ to sql_.
-\layout Itemize
-
-Added the option of using exceptions thoughout the API.
-\layout Itemize
-
-ColData (formally known as MysqlStrings) will now throw an exception if
- there is a problem in the conversion.
-\layout Itemize
-
-Added a null adapter.
-\layout Itemize
-
-Added Mutable Result Sets
-\layout Itemize
-
-Added a very basic runtime type identification for SQL types
-\layout Itemize
-
-Changed the document format from POD to LyX .
-\layout Itemize
-
-Am now using a modified version of Perceps to extract the class information
- directly from the code to make my life easier.
-\layout Itemize
-
-Added an option of defining a macro to avoid using the automatic conversion
- with binary operators.
-\layout Itemize
-
-Other small fixed I probully forgot to mentune.
-\layout Section*
-
-.63.1.a
-\layout Itemize
-
-Added Custom Mysql Structures.
-\layout Itemize
-
-Fixed the Copy constructor of class Mysql
-\layout Itemize
-
-Started adding code so that class Mysql lets it children now when it is
- leaving
-\layout Itemize
-
-Attempted to compile it into a library but still need help.
- As default it will compile as a regular program.
-\layout Itemize
-
-Other small fixes.
-\layout Section*
-
-.62.a (May 3 1998)
-\layout Itemize
-
-Added Template Queries
-\layout Itemize
-
-Created s separate SQLQuery object that is independent of an SQL connection.
-\layout Itemize
-
-You no longer have to import the data for the test program as the program
- creates the database and tables it needs.
-\layout Itemize
-
-Many small bug fixes.
-\layout Section*
-
-.61.1.a (April 28 1998)
-\layout Itemize
-
-Cleaned up the example code in test.cc and included it in the manual.
-\layout Itemize
-
-Added an interface layout plan to the manual.
-\layout Itemize
-
-Added a reverse iterator.
-\layout Itemize
-
-Fixed a bug with row.hh (It wasn't being included because of a typo).
-\layout Section*
-
-.61.0.a
-\layout Itemize
-
-Major interface changes.
- I warned you that the interface may change while it is in pre-alpha state
- and I wasn't kidding.
-\layout Itemize
-
-Created a new and Separate Query Object.
- You can no longer execute queries from the Mysql object instead you have
- to create a query object with Mysql::query() and use it to execute queries.
-\layout Itemize
-
-Added the comparison operators to MysqlDate, MysqlTime and MysqlDateTime.
- Fixed a few bugs in the MysqlDate...
- that effected the stream output and the conversion of them to strings.
-\layout Itemize
-
-Reflected the MysqlDate...
- changes in the manual.
-\layout Itemize
-
-Added a new MysqlSet object and a bunch of functions for working with mysql
- set strings.
- 
-\layout Section*
-
-.60.3a (April 24 1998)
-\layout Itemize
-
-Changed strtoq and strtouq to strtoll and strtull for metter compatibility
- Minor Manual fix.
-\layout Itemize
-
-Changed makefile to make it more compatible with Solaris (Thanks Chris H)
-\layout Itemize
-
-Fixed bug in comparison functions so that they would compare in he right
- direction.
-\layout Itemize
-
-Added some items to the to do list be sure to have a look.
-\layout Chapter
-
-To Do
-\layout Standard
-
-These are in the order I plan on implementing them.
-\layout Itemize
-
-Improve the runtime type identification system for the sql types which will
- be needed for the mutable results sets and the binary operators in particular.
-\layout Itemize
-
-Improve the mutable results sets so that they can be assigned types that
- are not strings setting the sql type aproprestly.
- Also allow the SQLtype to be fixed so that when the programmer assigned
- a type to the data field that is not compatible with that sql type it will
- through an exception.
- For example setting an string to an int.
-\layout Itemize
-
-Change the behavior of MysqlString when used with binary operators.
- Instead of converting to the type on the other side of the operator have
- it convert to the type the Mysql server said it originally was.
-\layout Itemize
-
-Improve the Null adapters to make them more intelligently.
-\layout Itemize
-
-Be able to store the result set in an assignable container that stores the
- results in the format they were originally stored in on the server.
- (Not sure what the best way to go about this is.
- If you have any ideas let me know.) 
-\layout Itemize
-
-Better handling of the destruction of the Mysql class.
- Have it first tell all its children that its parent is getting destroys
- and have then respond appropreatly.
- (Partly implemented as of version .63.1.a) 
-\layout Itemize
-
-Create a container to hold Mysql enums and sets as a bit set as opposed
- to a list of STL set.
- 
-\layout Itemize
-
-Have a more intelligent MysqlRes that can reexecute to refresh the data.
- 
-\layout Itemize
-
-Create full fledged client side cursors
-\layout Standard
-
-If you have anything else you want to see let us know at sinisa@cytanet.com.cy
- or monty@mysql.com.
- 
-\layout Chapter
-
-Credits
-\layout Standard
-
-The following is an informal list of programs and people I would like to
- thank.
-\layout Itemize
-
-egcs - for the great compiler (egcs.cygnus.com)
-\layout Itemize
-
-Perl - for making my life in general a lot easier (www.perl.com)
-\layout Itemize
-
-Lyx - as a great tool for helping me with this manual (www.lyx.org)
-\layout Itemize
-
-perceps - As a great tool for extracting documentation from the source (friga.mer.
-utexas.edu/mark/perl/perceps/)
-\layout Itemize
-
-latex2html - For making the html version of this document possible (www-dsed.llnl.
-gov/files/programs/unix/latex2html/)
-\layout Itemize
-
-lynx - For manking the text version of this document possible.
-\layout Itemize
-
-Mysql - for obvious reasons (www.tcx.se)
-\layout Itemize
-
-Xemacs - the editor of choice
-\layout Itemize
-
-Debian/GNU Linux - The platform I developed this on (www.debian.org)
-\layout Itemize
-
-Chris Halverson - For helping me get it to compile under Solaris.
-\layout Itemize
-
-Fredric Fredricson - For a long talk about automatic conversions.
-\layout Itemize
-
-Michael Widenius - Mysql developer who has been very supportive of my efforts.
-\layout Itemize
-
-Paul J.
- Lucas -For the original idea of treating the query object like a stream.
-\layout Itemize
-
-Scott Barron - For helping me with the shared libraries.
-\layout Itemize
-
-Jools Enticknap - For giving me the Template Queries Idea.
-\layout Itemize
-
-M.
- S.
- Sriram - For a detailed dission of how the Template Queries should be implement
-ed, the suggestion to throw exceptions on bad queries, and the idea of having
- a back-end independent query object (ie SQLQuery).
-\layout Itemize
-
-Sinisa Milivojevic - For becoming the new offical maintainer.
-\layout Standard
-
-If you fell that I forgot something please let me know.
-\layout Chapter
-
-Copyright
-\layout Standard
-
-The Mysql++ API is copyright 1998 by Kevin Atkinson and 1999 by MySQL and
- is released under the LGPL license .
-\layout Standard
-
-The intent of doing this is allow developers to use my library to develop
- commercial programs and to allow it be distributed with commercial databases.
-\layout Section
-
-LGPL
-\layout Standard
-\align center 
-GNU LIBRARY GENERAL PUBLIC LICENSE 
-\newline 
-Version 2, June 1991
-\layout Standard
-
-Copyright (C) 1991 Free Software Foundation, Inc.
- 
-\layout Quote
-
-59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
-\layout Standard
-
-Everyone is permitted to copy and distribute verbatim copies of this license
- document, but changing it is not allowed.
-\layout Standard
-
-[This is the first released version of the library GPL.
- It is numbered 2 because it goes with version 2 of the ordinary GPL.]
-\layout Standard
-\align center 
-Preamble
-\layout Standard
-
-The licenses for most software are designed to take away your freedom to
- share and change it.
- By contrast, the GNU General Public Licenses are intended to guarantee
- your freedom to share and change free software--to make sure the software
- is free for all its users.
-\layout Standard
-
-This license, the Library General Public License, applies to some specially
- designated Free Software Foundation software, and to any other libraries
- whose authors decide to use it.
- You can use it for your libraries, too.
-\layout Standard
-
-When we speak of free software, we are referring to freedom, not price.
- Our General Public Licenses are designed to make sure that you have the
- freedom to distribute copies of free software (and charge for this service
- if you wish), that you receive source code or can get it if you want it,
- that you can change the software or use pieces of it in new free programs;
- and that you know you can do these things.
-\layout Standard
-
-To protect your rights, we need to make restrictions that forbid anyone
- to deny you these rights or to ask you to surrender the rights.
- These restrictions translate to certain responsibilities for you if you
- distribute copies of the library, or if you modify it.
-\layout Standard
-
-For example, if you distribute copies of the library, whether gratis or
- for a fee, you must give the recipients all the rights that we gave you.
- You must make sure that they, too, receive or can get the source code.
- If you link a program with the library, you must provide complete object
- files to the recipients so that they can relink them with the library,
- after making changes to the library and recompiling it.
- And you must show them these terms so they know their rights.
-\layout Standard
-
-Our method of protecting your rights has two steps: (1) copyright the library,
- and (2) offer you this license which gives you legal permission to copy,
- distribute and/or modify the library.
-\layout Standard
-
-Also, for each distributor's protection, we want to make certain that everyone
- understands that there is no warranty for this free library.
- If the library is modified by someone else and passed on, we want its recipient
-s to know that what they have is not the original version, so that any problems
- introduced by others will not reflect on the original authors' reputations.
-\layout Standard
-
-Finally, any free program is threatened constantly by software patents.
- We wish to avoid the danger that companies distributing free software will
- individually obtain patent licenses, thus in effect transforming the program
- into proprietary software.
- To prevent this, we have made it clear that any patent must be licensed
- for everyone's free use or not licensed at all.
-\layout Standard
-
-Most GNU software, including some libraries, is covered by the ordinary
- GNU General Public License, which was designed for utility programs.
- This license, the GNU Library General Public License, applies to certain
- designated libraries.
- This license is quite different from the ordinary one; be sure to read
- it in full, and don't assume that anything in it is the same as in the
- ordinary license.
-\layout Standard
-
-The reason we have a separate public license for some libraries is that
- they blur the distinction we usually make between modifying or adding to
- a program and simply using it.
- Linking a program with a library, without changing the library, is in some
- sense simply using the library, and is analogous to running a utility program
- or application program.
- However, in a textual and legal sense, the linked executable is a combined
- work, a derivative of the original library, and the ordinary General Public
- License treats it as such.
-\layout Standard
-
-Because of this blurred distinction, using the ordinary General Public License
- for libraries did not effectively promote software sharing, because most
- developers did not use the libraries.
- We concluded that weaker conditions might promote sharing better.
-\layout Standard
-
-However, unrestricted linking of non-free programs would deprive the users
- of those programs of all benefit from the free status of the libraries
- themselves.
- This Library General Public License is intended to permit developers of
- non-free programs to use free libraries, while preserving your freedom
- as a user of such programs to change the free libraries that are incorporated
- in them.
- (We have not seen how to achieve this as regards changes in header files,
- but we have achieved it as regards changes in the actual functions of the
- Library.) The hope is that this will lead to faster development of free
- libraries.
-\layout Standard
-
-The precise terms and conditions for copying, distribution and modification
- follow.
- Pay close attention to the difference between a "work based on the library"
- and a "work that uses the library".
- The former contains code derived from the library, while the latter only
- works together with the library.
-\layout Standard
-
-Note that it is possible for a library to be covered by the ordinary General
- Public License rather than by this special one.
-\layout Standard
-\align center 
-GNU LIBRARY GENERAL PUBLIC LICENSE
-\newline 
-TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-\layout Standard
-
-0.
- This License Agreement applies to any software library which contains a
- notice placed by the copyright holder or other authorized party saying
- it may be distributed under the terms of this Library General Public License
- (also called "this License").
- Each licensee is addressed as "you".
-\layout Standard
-
-A "library" means a collection of software functions and/or data prepared
- so as to be conveniently linked with application programs (which use some
- of those functions and data) to form executables.
-\layout Standard
-
-The "Library", below, refers to any such software library or work which
- has been distributed under these terms.
- A "work based on the Library" means either the Library or any derivative
- work under copyright law: that is to say, a work containing the Library
- or a portion of it, either verbatim or with modifications and/or translated
- straightforwardly into another language.
- (Hereinafter, translation is included without limitation in the term "modificat
-ion".)
-\layout Standard
-
-"Source code" for a work means the preferred form of the work for making
- modifications to it.
- For a library, complete source code means all the source code for all modules
- it contains, plus any associated interface definition files, plus the scripts
- used to control compilation and installation of the library.
-\layout Standard
-
-Activities other than copying, distribution and modification are not covered
- by this License; they are outside its scope.
- The act of running a program using the Library is not restricted, and output
- from such a program is covered only if its contents constitute a work based
- on the Library (independent of the use of the Library in a tool for writing
- it).
- Whether that is true depends on what the Library does and what the program
- that uses the Library does.
- 1.
- You may copy and distribute verbatim copies of the Library's complete source
- code as you receive it, in any medium, provided that you conspicuously
- and appropriately publish on each copy an appropriate copyright notice
- and disclaimer of warranty; keep intact all the notices that refer to this
- License and to the absence of any warranty; and distribute a copy of this
- License along with the Library.
-\layout Standard
-
-You may charge a fee for the physical act of transferring a copy, and you
- may at your option offer warranty protection in exchange for a fee.
-\layout Standard
-
-2.
- You may modify your copy or copies of the Library or any portion of it,
- thus forming a work based on the Library, and copy and distribute such
- modifications or work under the terms of Section 1 above, provided that
- you also meet all of these conditions:
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-a) The modified work must itself be a software library.
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-b) You must cause the files modified to carry prominent notices stating
- that you changed the files and the date of any change.
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-c) You must cause the whole of the work to be licensed at no charge to all
- third parties under the terms of this License.
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-d) If a facility in the modified Library refers to a function or a table
- of data to be supplied by an application program that uses the facility,
- other than as an argument passed when the facility is invoked, then you
- must make a good faith effort to ensure that, in the event an application
- does not supply such function or table, the facility still operates, and
- performs whatever part of its purpose remains meaningful.
-\layout Standard
-
-(For example, a function in a library to compute square roots has a purpose
- that is entirely well-defined independent of the application.
- Therefore, Subsection 2d requires that any application-supplied function
- or table used by this function must be optional: if the application does
- not supply it, the square root function must still compute square roots.)
-\layout Standard
-
-These requirements apply to the modified work as a whole.
- If identifiable sections of that work are not derived from the Library,
- and can be reasonably considered independent and separate works in themselves,
- then this License, and its terms, do not apply to those sections when you
- distribute them as separate works.
- But when you distribute the same sections as part of a whole which is a
- work based on the Library, the distribution of the whole must be on the
- terms of this License, whose permissions for other licensees extend to
- the entire whole, and thus to each and every part regardless of who wrote
- it.
-\layout Standard
-
-Thus, it is not the intent of this section to claim rights or contest your
- rights to work written entirely by you; rather, the intent is to exercise
- the right to control the distribution of derivative or collective works
- based on the Library.
-\layout Standard
-
-In addition, mere aggregation of another work not based on the Library with
- the Library (or with a work based on the Library) on a volume of a storage
- or distribution medium does not bring the other work under the scope of
- this License.
-\layout Standard
-
-3.
- You may opt to apply the terms of the ordinary GNU General Public License
- instead of this License to a given copy of the Library.
- To do this, you must alter all the notices that refer to this License,
- so that they refer to the ordinary GNU General Public License, version
- 2, instead of to this License.
- (If a newer version than version 2 of the ordinary GNU General Public License
- has appeared, then you can specify that version instead if you wish.) Do
- not make any other change in these notices.
-\layout Standard
-
-Once this change is made in a given copy, it is irreversible for that copy,
- so the ordinary GNU General Public License applies to all subsequent copies
- and derivative works made from that copy.
-\layout Standard
-
-This option is useful when you wish to copy part of the code of the Library
- into a program that is not a library.
-\layout Standard
-
-4.
- You may copy and distribute the Library (or a portion or derivative of
- it, under Section 2) in object code or executable form under the terms
- of Sections 1 and 2 above provided that you accompany it with the complete
- corresponding machine-readable source code, which must be distributed under
- the terms of Sections 1 and 2 above on a medium customarily used for software
- interchange.
-\layout Standard
-
-If distribution of object code is made by offering access to copy from a
- designated place, then offering equivalent access to copy the source code
- from the same place satisfies the requirement to distribute the source
- code, even though third parties are not compelled to copy the source along
- with the object code.
-\layout Standard
-
-5.
- A program that contains no derivative of any portion of the Library, but
- is designed to work with the Library by being compiled or linked with it,
- is called a "work that uses the Library".
- Such a work, in isolation, is not a derivative work of the Library, and
- therefore falls outside the scope of this License.
-\layout Standard
-
-However, linking a "work that uses the Library" with the Library creates
- an executable that is a derivative of the Library (because it contains
- portions of the Library), rather than a "work that uses the library".
- The executable is therefore covered by this License.
- Section 6 states terms for distribution of such executables.
-\layout Standard
-
-When a "work that uses the Library" uses material from a header file that
- is part of the Library, the object code for the work may be a derivative
- work of the Library even though the source code is not.
- Whether this is true is especially significant if the work can be linked
- without the Library, or if the work is itself a library.
- The threshold for this to be true is not precisely defined by law.
-\layout Standard
-
-If such an object file uses only numerical parameters, data structure layouts
- and accessors, and small macros and small inline functions (ten lines or
- less in length), then the use of the object file is unrestricted, regardless
- of whether it is legally a derivative work.
- (Executables containing this object code plus portions of the Library will
- still fall under Section 6.)
-\layout Standard
-
-Otherwise, if the work is a derivative of the Library, you may distribute
- the object code for the work under the terms of Section 6.
- Any executables containing that work also fall under Section 6, whether
- or not they are linked directly with the Library itself.
-\layout Standard
-
-6.
- As an exception to the Sections above, you may also compile or link a "work
- that uses the Library" with the Library to produce a work containing portions
- of the Library, and distribute that work under terms of your choice, provided
- that the terms permit modification of the work for the customer's own use
- and reverse engineering for debugging such modifications.
-\layout Standard
-
-You must give prominent notice with each copy of the work that the Library
- is used in it and that the Library and its use are covered by this License.
- You must supply a copy of this License.
- If the work during execution displays copyright notices, you must include
- the copyright notice for the Library among them, as well as a reference
- directing the user to the copy of this License.
- Also, you must do one of these things:
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-a) Accompany the work with the complete corresponding machine-readable source
- code for the Library including whatever changes were used in the work (which
- must be distributed under Sections 1 and 2 above); and, if the work is
- an executable linked with the Library, with the complete machine-readable
- "work that uses the Library", as object code and/or source code, so that
- the user can modify the Library and then relink to produce a modified executabl
-e containing the modified Library.
- (It is understood that the user who changes the contents of definitions
- files in the Library will not necessarily be able to recompile the application
- to use the modified definitions.)
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-b) Accompany the work with a written offer, valid for at least three years,
- to give the same user the materials specified in Subsection 6a, above,
- for a charge no more than the cost of performing this distribution.
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-c) If distribution of the work is made by offering access to copy from a
- designated place, offer equivalent access to copy the above specified materials
- from the same place.
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-d) Verify that the user has already received a copy of these materials or
- that you have already sent this user a copy.
-\layout Standard
-
-For an executable, the required form of the "work that uses the Library"
- must include any data and utility programs needed for reproducing the executabl
-e from it.
- However, as a special exception, the source code distributed need not include
- anything that is normally distributed (in either source or binary form)
- with the major components (compiler, kernel, and so on) of the operating
- system on which the executable runs, unless that component itself accompanies
- the executable.
-\layout Standard
-
-It may happen that this requirement contradicts the license restrictions
- of other proprietary libraries that do not normally accompany the operating
- system.
- Such a contradiction means you cannot use both them and the Library together
- in an executable that you distribute.
-\layout Standard
-
-7.
- You may place library facilities that are a work based on the Library side-by-s
-ide in a single library together with other library facilities not covered
- by this License, and distribute such a combined library, provided that
- the separate distribution of the work based on the Library and of the other
- library facilities is otherwise permitted, and provided that you do these
- two things:
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-a) Accompany the combined library with a copy of the same work based on
- the Library, uncombined with any other library facilities.
- This must be distributed under the terms of the Sections above.
-\layout Standard
-\pextra_type 1 \pextra_width 0.5in
-
-b) Give prominent notice with the combined library of the fact that part
- of it is a work based on the Library, and explaining where to find the
- accompanying uncombined form of the same work.
-\layout Standard
-
-8.
- You may not copy, modify, sublicense, link with, or distribute the Library
- except as expressly provided under this License.
- Any attempt otherwise to copy, modify, sublicense, link with, or distribute
- the Library is void, and will automatically terminate your rights under
- this License.
- However, parties who have received copies, or rights, from you under this
- License will not have their licenses terminated so long as such parties
- remain in full compliance.
-\layout Standard
-
-9.
- You are not required to accept this License, since you have not signed
- it.
- However, nothing else grants you permission to modify or distribute the
- Library or its derivative works.
- These actions are prohibited by law if you do not accept this License.
- Therefore, by modifying or distributing the Library (or any work based
- on the Library), you indicate your acceptance of this License to do so,
- and all its terms and conditions for copying, distributing or modifying
- the Library or works based on it.
-\layout Standard
-
-10.
- Each time you redistribute the Library (or any work based on the Library),
- the recipient automatically receives a license from the original licensor
- to copy, distribute, link with or modify the Library subject to these terms
- and conditions.
- You may not impose any further restrictions on the recipients' exercise
- of the rights granted herein.
- You are not responsible for enforcing compliance by third parties to this
- License.
-\layout Standard
-
-11.
- If, as a consequence of a court judgment or allegation of patent infringement
- or for any other reason (not limited to patent issues), conditions are
- imposed on you (whether by court order, agreement or otherwise) that contradict
- the conditions of this License, they do not excuse you from the conditions
- of this License.
- If you cannot distribute so as to satisfy simultaneously your obligations
- under this License and any other pertinent obligations, then as a consequence
- you may not distribute the Library at all.
- For example, if a patent license would not permit royalty-free redistribution
- of the Library by all those who receive copies directly or indirectly through
- you, then the only way you could satisfy both it and this License would
- be to refrain entirely from distribution of the Library.
-\layout Standard
-
-If any portion of this section is held invalid or unenforceable under any
- particular circumstance, the balance of the section is intended to apply,
- and the section as a whole is intended to apply in other circumstances.
-\layout Standard
-
-It is not the purpose of this section to induce you to infringe any patents
- or other property right claims or to contest validity of any such claims;
- this section has the sole purpose of protecting the integrity of the free
- software distribution system which is implemented by public license practices.
- Many people have made generous contributions to the wide range of software
- distributed through that system in reliance on consistent application of
- that system; it is up to the author/donor to decide if he or she is willing
- to distribute software through any other system and a licensee cannot impose
- that choice.
-\layout Standard
-
-This section is intended to make thoroughly clear what is believed to be
- a consequence of the rest of this License.
-\layout Standard
-
-12.
- If the distribution and/or use of the Library is restricted in certain
- countries either by patents or by copyrighted interfaces, the original
- copyright holder who places the Library under this License may add an explicit
- geographical distribution limitation excluding those countries, so that
- distribution is permitted only in or among countries not thus excluded.
- In such case, this License incorporates the limitation as if written in
- the body of this License.
-\layout Standard
-
-13.
- The Free Software Foundation may publish revised and/or new versions of
- the Library General Public License from time to time.
- Such new versions will be similar in spirit to the present version, but
- may differ in detail to address new problems or concerns.
-\layout Standard
-
-Each version is given a distinguishing version number.
- If the Library specifies a version number of this License which applies
- to it and "any later version", you have the option of following the terms
- and conditions either of that version or of any later version published
- by the Free Software Foundation.
- If the Library does not specify a license version number, you may choose
- any version ever published by the Free Software Foundation.
-\layout Standard
-
-14.
- If you wish to incorporate parts of the Library into other free programs
- whose distribution conditions are incompatible with these, write to the
- author to ask for permission.
- For software which is copyrighted by the Free Software Foundation, write
- to the Free Software Foundation; we sometimes make exceptions for this.
- Our decision will be guided by the two goals of preserving the free status
- of all derivatives of our free software and of promoting the sharing and
- reuse of software generally.
-\layout Standard
-\align center 
-NO WARRANTY
-\layout Standard
-
-15.
- BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
- THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
- EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER
- PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
- EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
- THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
- YOU.
- SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
- SERVICING, REPAIR OR CORRECTION.
-\layout Standard
-
-16.
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
- ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
- THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
- ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF
- THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS
- OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR
- THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE),
- EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY
- OF SUCH DAMAGES.
-\layout Standard
-\align center 
-END OF TERMS AND CONDITIONS
-\layout Standard
-\align center 
-How to Apply These Terms to Your New Libraries
-\layout Standard
-
-If you develop a new library, and you want it to be of the greatest possible
- use to the public, we recommend making it free software that everyone can
- redistribute and change.
- You can do so by permitting redistribution under these terms (or, alternatively
-, under the terms of the ordinary General Public License).
-\layout Standard
-
-To apply these terms, attach the following notices to the library.
- It is safest to attach them to the start of each source file to most effectivel
-y convey the exclusion of warranty; and each file should have at least the
- "copyright" line and a pointer to where the full notice is found.
-\layout Quote
-
-<one line to give the library's name and a brief idea of what it does.>
-\newline 
-Copyright (C) <year> <name of author>
-\layout Quote
-
-This library is free software; you can redistribute it and/or modify it
- under the terms of the GNU Library General Public License as published
- by the Free Software Foundation; either version 2 of the License, or (at
- your option) any later version.
-\layout Quote
-
-This library is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- FOR A PARTICULAR PURPOSE.
- See the GNU Library General Public License for more details.
-\layout Quote
-
-You should have received a copy of the GNU Library General Public License
- along with this library; if not, write to the Free Foundation, Inc., 59
- Temple Place, Suite 330, Boston, MA 02111-1307 USA
-\layout Standard
-
-Also add information on how to contact you by electronic and paper mail.
-\layout Standard
-
-You should also get your employer (if you work as a programmer) or your
- school, if any, to sign a "copyright disclaimer" for the library, if necessary.
- Here is a sample; alter the names:
-\layout Quote
-
-Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob'
- (a library for tweaking knobs) written by James Random Hacker.
-\layout Quote
-
-<signature of Ty Coon>, 1 April 1990 Ty Coon, President of Vice
-\layout Standard
-
-That's all there is to it!
-\layout Chapter
-
-Feedback
-\layout Standard
-
-Since October 1999, all maintenance has been transferred to Sinisa Milivojevic
- (sinisa@cytanet.com.cy) and Michael Widenius (monty@mysql.com).
-\layout Standard
-
-Send your feedback to any of these addresses, or even better to the mailing
- list mysql-plusplus@lists.mysql.com.
-\the_end

DELETED doc/pretty.pl
Index: doc/pretty.pl
==================================================================
--- doc/pretty.pl
+++ /dev/null
@@ -1,75 +0,0 @@
-use FileHandle;
-use IPC::Open2;
-
-if ($ARGV[0] =~ /^--command\=(.+)/) {
-    $command = $1;
-} else {
-    $command = "g++ -E";
-}
-
-$/ = undef;
-$orgcode = <STDIN>;
-
-($macro) = $orgcode =~ /(sql_create_.+? *\(.+?\))/s;
-
-$out = << "---";
-
-#include <sqlplusint/custom-macros.hh>
-
-$macro
-
----
-
-$/ = "\n";
-
-$temp_dir = -d '/tmp' ? '/tmp' : $ENV{TMP} || $ENV{TEMP};
-
-#print $out;
-
-open OUT, ">$temp_dir/${$}.cc";
-print OUT $out;
-close OUT;
-
-system "$command $temp_dir/${$}.cc > $temp_dir/${$}.ii";
-
-open IN, "$temp_dir/${$}.ii";
-while (<IN>) {
-    next if /^\#/;    
-    $code .= $_;
-}
-close IN;
-
-unlink "$temp_dir/${$}.cc","$temp_dir/${$}.ii";
-
-$_ = $code;
-s/\s+/ /g;
-s/ *public: */public:\n/g;
-s/ *private: */public:\n/g;
-s/ *\; */\;\n/g;
-s/ *\{ */ \{\n/g;
-s/ *\} */ \}\n\n/g;
-s/ *\n */\n/g;
-s/\{\s+}/\{\}/g;
-s/\}\s+\;/\}\;\n/g;
-
-$code = "";
-foreach (split /\n/) {
-    if (/\}/ && !/\{\}/ ) {
-	$indent -= 2;
-	$ind = ' 'x$indent;
-    }
-    $code .= "$ind$_\n" unless /\:$/;
-    $code .= "$_\n"     if     /\:$/;
-    if (/\{/ && !/\{\}/ ) {
-	$indent += 2;
-	$ind = ' 'x$indent;
-    } 
-}
-
-$orgcode =~ s/(sql_create_.+? *\(.+?\))/\n$code\n/s;
-
-print $orgcode;
-
-
-
-

DELETED doc/sql++pretty
Index: doc/sql++pretty
==================================================================
--- doc/sql++pretty
+++ /dev/null
@@ -1,75 +0,0 @@
-use FileHandle;
-use IPC::Open2;
-
-if ($ARGV[0] =~ /^--command\=(.+)/) {
-    $command = $1;
-} else {
-    $command = "g++ -E";
-}
-
-$/ = undef;
-$orgcode = <STDIN>;
-
-($macro) = $orgcode =~ /(sql_create_.+? *\(.+?\))/s;
-
-$out = << "---";
-
-#include <sqlplusint/custom-macros.hh>
-
-$macro
-
----
-
-$/ = "\n";
-
-$temp_dir = -d '/tmp' ? '/tmp' : $ENV{TMP} || $ENV{TEMP};
-
-#print $out;
-
-open OUT, ">$temp_dir/${$}.cc";
-print OUT $out;
-close OUT;
-
-system "$command $temp_dir/${$}.cc > $temp_dir/${$}.ii";
-
-open IN, "$temp_dir/${$}.ii";
-while (<IN>) {
-    next if /^\#/;    
-    $code .= $_;
-}
-close IN;
-
-unlink "$temp_dir/${$}.cc","$temp_dir/${$}.ii";
-
-$_ = $code;
-s/\s+/ /g;
-s/ *public: */public:\n/g;
-s/ *private: */public:\n/g;
-s/ *\; */\;\n/g;
-s/ *\{ */ \{\n/g;
-s/ *\} */ \}\n\n/g;
-s/ *\n */\n/g;
-s/\{\s+}/\{\}/g;
-s/\}\s+\;/\}\;\n/g;
-
-$code = "";
-foreach (split /\n/) {
-    if (/\}/ && !/\{\}/ ) {
-	$indent -= 2;
-	$ind = ' 'x$indent;
-    }
-    $code .= "$ind$_\n" unless /\:$/;
-    $code .= "$_\n"     if     /\:$/;
-    if (/\{/ && !/\{\}/ ) {
-	$indent += 2;
-	$ind = ' 'x$indent;
-    } 
-}
-
-$orgcode =~ s/(sql_create_.+? *\(.+?\))/\n$code\n/s;
-
-print $orgcode;
-
-
-
-

ADDED   doc/ssqls-pretty
Index: doc/ssqls-pretty
==================================================================
--- /dev/null
+++ doc/ssqls-pretty
@@ -0,0 +1,83 @@
+#!/usr/bin/perl
+use FileHandle;
+use IPC::Open2;
+
+if ($ARGV[0] =~ /^--command\=(.+)/) {
+    $command = $1;
+} else {
+    $command = "g++ -E -I /usr/include/mysql";
+}
+
+if (-e 'lib/mysql++.h') {
+	$command .= " -I lib";
+}
+else {
+	$command .= " -I /usr/include/mysql++/";
+}
+
+$/ = undef;
+$orgcode = <STDIN>;
+
+($macro) = $orgcode =~ /(sql_create_.+? *\(.+?\))/s;
+
+$out = << "---";
+
+#include <ssqls.h>
+
+$macro
+
+---
+
+$/ = "\n";
+
+$temp_dir = -d '/tmp' ? '/tmp' : $ENV{TMP} || $ENV{TEMP};
+
+#print $out;
+
+open OUT, ">$temp_dir/${$}.cc";
+print OUT $out;
+close OUT;
+
+system "$command $temp_dir/${$}.cc > $temp_dir/${$}.ii";
+
+open IN, "$temp_dir/${$}.ii";
+while (<IN>) {
+    next if /^\#/;    
+    $code .= $_;
+}
+close IN;
+
+unlink "$temp_dir/${$}.cc","$temp_dir/${$}.ii";
+
+$_ = $code;
+s/\s+/ /g;
+s/ *public: */public:\n/g;
+s/ *private: */public:\n/g;
+s/ *\; */\;\n/g;
+s/ *\{ */ \{\n/g;
+s/ *\} */ \}\n\n/g;
+s/ *\n */\n/g;
+s/\{\s+}/\{\}/g;
+s/\}\s+\;/\}\;\n/g;
+
+$code = "";
+foreach (split /\n/) {
+    if (/\}/ && !/\{\}/ ) {
+	$indent -= 2;
+	$ind = ' 'x$indent;
+    }
+    $code .= "$ind$_\n" unless /\:$/;
+    $code .= "$_\n"     if     /\:$/;
+    if (/\{/ && !/\{\}/ ) {
+	$indent += 2;
+	$ind = ' 'x$indent;
+    } 
+}
+
+$orgcode =~ s/(sql_create_.+? *\(.+?\))/\n$code\n/s;
+
+print $orgcode;
+
+
+
+

ADDED   doc/userman/Makefile
Index: doc/userman/Makefile
==================================================================
--- /dev/null
+++ doc/userman/Makefile
@@ -0,0 +1,66 @@
+## ------------------------
+## Input files
+## ------------------------
+
+HTML_DIR=../html/userman
+BASENAME=userman
+DOCFILE=$(BASENAME).dbx
+PDFFILE=$(BASENAME).pdf
+FOFILE=$(BASENAME).fo
+COMMON_SS=common.xsl
+FO_SS=fo.xsl
+HTML_SS=html.xsl
+EX_TXT=cgi_jpeg.txt cpool.txt deadlock.txt fieldinf.txt for_each.txt \
+		load_jpeg.txt multiquery.txt resetdb.txt simple1.txt \
+		simple2.txt simple3.txt ssqls1.txt ssqls2.txt ssqls3.txt \
+		ssqls4.txt ssqls5.txt stock.txt store_if.txt tquery1.txt \
+		transaction.txt
+
+
+## ------------------------
+## Major output rules
+## ------------------------
+
+html: $(HTML_DIR)/index.html
+
+pdf: $(PDFFILE)
+
+
+## ------------------------
+## Standard Makefile targets
+## ------------------------
+
+# Notice that this is not the first target in the file, as is standard.
+# PDF generation takes longer than HTML generation, so to keep the code-
+# test-debug-rebuild cycle short, we generate only the HTML manual by
+# default.  You can explicitly say "make pdf" or "make all" when you're
+# sure the DocBook file's contents are correct.
+all: html pdf
+
+clean:
+	rm -f tags *.fo $(HTML_DIR)/*.html *.log *.out *.pdf *.txt
+
+
+## ------------------------
+## How to make output files
+## ------------------------
+
+$(PDFFILE): *.dbx *.in $(FO_SS) $(COMMON_SS)
+	xsltproc --nonet --xinclude $(FO_SS) $(DOCFILE) > $(FOFILE)
+	./fo2pdf $(FOFILE) $(PDFFILE)
+	mkdir -p ../pdf && cp $(PDFFILE) ../pdf
+
+$(HTML_DIR)/index.html: *.dbx *.in $(EX_TXT) $(HTML_SS) $(COMMON_SS)
+	@xmllint --nonet --xinclude --postvalid --noent --noout $(DOCFILE)
+	xsltproc --nonet --xinclude -o $(HTML_DIR)/ $(HTML_SS) $(DOCFILE)
+
+
+## ------------------------
+## Dependency rules
+## ------------------------
+
+$(EX_TXT):
+	@./mktxt $@
+
+userman.dbx: userman.dbx.in
+	( cd ../.. ; ./config.status )

ADDED   doc/userman/breakages.dbx
Index: doc/userman/breakages.dbx
==================================================================
--- /dev/null
+++ doc/userman/breakages.dbx
@@ -0,0 +1,1122 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="breakages">
+  <title>Incompatible Library Changes</title>
+
+  <para>This chapter documents those library changes since the epochal
+  1.7.9 release that break end-user programs. You can dig this stuff out
+  of the ChangeLog, but the ChangeLog focuses more on explaining and
+  justifying the facets of each change, while this section focuses on
+  how to migrate your code between these library versions.</para>
+
+  <para>Since pure additions do not break programs, those changes are
+  still documented only in the ChangeLog.</para>
+
+
+  <sect2 id="api-changes">
+    <title>API Changes</title>
+
+    <para>This section documents files, functions, methods and classes
+    that were removed or changed in an incompatible way. If your program
+    uses the changed item, you will have to change something in your
+    program to get it to compile after upgrading to each of these
+    versions.</para>
+
+    <sect3 id="api-1.7.10">
+      <title>v1.7.10</title>
+
+      <para>Removed <methodname>Row::operator[]()</methodname> overloads
+      except the one for <type>size_type</type>, and added
+      <methodname>Row::lookup_by_name()</methodname> to provide the
+      &ldquo;subscript by string&rdquo; functionality.  In practical
+      terms, this change means that the <varname>row["field"]</varname>
+      syntax no longer works; you must use the new
+      <methodname>lookup_by_name</methodname> method instead.</para>
+
+      <para>Renamed the generated library on POSIX systems from
+      <filename>libsqlplus</filename> to
+      <filename>libmysqlpp</filename>.</para>
+    </sect3>
+
+
+    <sect3 id="api-1.7.19">
+      <title>v1.7.19</title>
+
+      <para>Removed <methodname>SQLQuery::operator=()</methodname>, and
+      the same for its <classname>Query</classname> subclass. Use the
+      copy constructor instead, if you need to copy one query to another
+      query object.</para>
+    </sect3>
+
+
+    <sect3 id="api-1.7.20">
+      <title>v1.7.20</title>
+
+      <para>The library used to have two names for many core classes: a
+      short one, such as <classname>Row</classname> and a longer one,
+      <classname>MysqlRow</classname>. The library now uses the shorter
+      names exclusively.</para>
+
+      <para>All symbols within MySQL++ are in the
+      <filename>mysqlpp</filename> namespace now if you use the new
+      <filename>mysql++.h</filename> header. If you use the older
+      <filename>sqlplus.hh</filename> or <filename>mysql++.hh</filename>
+      headers, these symbols are hoist up into the global namespace. The
+      older headers cause the compiler to emit warnings if you use them,
+      and they will go away someday.</para>
+    </sect3>
+
+ 
+    <sect3 id="api-2.0.0">
+      <title>v2.0.0</title>
+
+      <sect4 id="api-2.0.0-Connection">
+        <title>Connection class changes</title>
+
+        <itemizedlist>
+          <listitem><para><methodname>Connection::create_db()</methodname>
+          and <methodname>drop_db()</methodname> return
+          <symbol>true</symbol> on success. They returned
+          <symbol>false</symbol> in v1.7.<emphasis>x</emphasis>! This
+          change will only affect your code if you have exceptions
+          disabled.</para></listitem>
+
+          <listitem><para>Renamed
+          <methodname>Connection::real_connect()</methodname>
+          to <methodname>connect()</methodname>, made several
+          more of its parameters default, and removed the
+          old <methodname>connect()</methodname> method, as
+          it&rsquo;s now a strict subset of the new one. The
+          only practical consequence is that if your program
+          was using <methodname>real_connect()</methodname>,
+          you will have to change it to
+          <methodname>connect()</methodname>.</para></listitem>
+
+          <listitem><para>Replaced
+          <methodname>Connection::read_option()</methodname> with new
+          <methodname>set_option()</methodname> mechanism. In addition
+          to changing the name, programs using this function will have
+          to use the new <classname>Connection::Option</classname>
+          enumerated values, accept a <symbol>true</symbol>
+          return value as meaning success instead of 0, and
+          use the proper argument type. Regarding the latter,
+          <methodname>read_option()</methodname> took a <type>const
+          char*</type> argument, but because it was just a thin wrapper
+          over the MySQL C API function <ulink url="mysql-options"
+          type="mysqlapi"/>, the actual value being pointed to could
+          be any of several types. This new mechanism is properly
+          type-safe.</para></listitem>
+        </itemizedlist>
+      </sect4>
+
+
+      <sect4 id="api-2.0.0-Exception">
+        <title>Exception-related changes</title>
+
+        <itemizedlist>
+          <listitem><para>Classes <classname>Connection</classname>,
+          <classname>Query</classname>, <classname>Result</classname>,
+          <classname>ResUse</classname>, and <classname>Row</classname>
+          now derive from <ulink type="classref"
+          url="OptionalExceptions"/> which gives these classes a common
+          interface for disabling exceptions. In addition, almost all
+          of the per-method exception-disabling flags were removed. The
+          preferred method for disabling exceptions on these objects
+          is to create an instance of the new <ulink type="classref"
+          url="NoExceptions"/> class on the stack, which disables
+          exceptions on an <classname>OptionalExceptions</classname>
+          subclass as long as the <classname>NoExceptions</classname>
+          instance is in scope. You can instead call
+          <methodname>disable_exceptions()</methodname> on any
+          of these objects, but if you only want them disabled
+          temporarily, it&rsquo;s easy to forget to re-enable them
+          later.</para></listitem>
+
+          <listitem><para>In the previous version of MySQL++,
+          those classes that supported optional exceptions that
+          could create instances of other such classes were
+          supposed to pass this flag on to their children. That
+          is, if you created a <classname>Connection</classname>
+          object with exceptions enabled, and then asked it to
+          create a <classname>Query</classname> object, the
+          <classname>Query</classname> object also had exceptions
+          disabled. The problem is, this didn&rsquo;t happen in all
+          cases where it should have in v1.7. This bug is fixed in
+          v2.0. If your program begins crashing due to uncaught
+          exceptions after upgrading to v2.0, this is the most likely
+          cause. The most expeditious fix in this situation is to
+          use the new <classname>NoExceptions</classname> feature to
+          return these code paths to the v1.7 behavior. A better fix
+          is to rework your program to avoid or deal with the new
+          exceptions.</para></listitem>
+
+          <listitem><para>All custom MySQL++ exceptions now derive from
+          the new <ulink type="classref" url="Exception"/> interface.
+          The practical upshot of this is that the variability between
+          the various exception types has been eliminated. For instance,
+          to get the error string, the <classname>BadQuery</classname>
+          exception had a string member called <varname>error</varname>
+          plus a method called <methodname>what()</methodname>. Both
+          did the same thing, and the <methodname>what()</methodname>
+          method is more common, so the error string was dropped
+          from the interface. None of the example programs had to be
+          changed to work with the new exceptions, so if your program
+          handles MySQL++ exceptions the same way they do, your program
+          won&rsquo;t need to change, either.</para></listitem>
+
+          <listitem><para>Renamed
+          <classname>SQLQueryNEParams</classname> exception to
+          <classname>BadParamCount</classname> to match style of other
+          exception names.</para></listitem>
+
+          <listitem><para>Added <ulink type="classref"
+          url="BadOption"/>, <ulink type="classref"
+          url="ConnectionFailed"/>, <ulink type="classref"
+          url="DBSelectionFailed"/>, <ulink type="classref"
+          url="EndOfResults"/>, <ulink type="classref"
+          url="EndOfResultSets"/>, <ulink type="classref"
+          url="LockFailed"/>, and <ulink type="classref"
+          url="ObjectNotInitialized"/> exception types, to fix
+          overuse of <classname>BadQuery</classname>. Now the
+          latter is used only for errors on query execution. If
+          your program has a &ldquo;catch-all&rdquo; block taking a
+          <classname>std::exception</classname> for each try block
+          containing MySQL++ statements, you probably won&rsquo;t
+          need to change your program. Otherwise, the new exceptions
+          will likely show up as program crashes due to unhandled
+          exceptions.</para></listitem>
+        </itemizedlist>
+      </sect4>
+
+
+      <sect4 id="api-2.0.0-Query">
+        <title>Query class changes</title>
+
+        <itemizedlist>
+
+          <listitem><para>In previous versions,
+          <classname>Connection</classname> had
+          a querying interface similar to class
+          <classname>Query</classname>&rsquo;s. These methods were
+          intended only for <classname>Query</classname>&rsquo;s use; no
+          example ever used this interface directly, so no end-user code
+          is likely to be affected by this change.</para></listitem>
+
+          <listitem><para>A more likely problem arising from
+          the above change is code that tests for query success
+          by calling the <classname>Connection</classname>
+          object&rsquo;s <methodname>success()</methodname> method
+          or by casting it to <type>bool</type>. This will now give
+          misleading results, because queries no longer go through
+          the <classname>Connection</classname> object. Class
+          <classname>Query</classname> has the same success-testing
+          interface, so use it instead.</para></listitem>
+
+          <listitem><para><classname>Query</classname> now derives
+          from <classname>std::ostream</classname> instead of
+          <classname>std::stringstream</classname>.</para></listitem>
+
+        </itemizedlist>
+      </sect4>
+
+
+      <sect4 id="api-2.0.0-Result">
+        <title>Result/ResUse class changes</title>
+
+        <itemizedlist>
+
+          <listitem><para>Renamed
+          <methodname>ResUse::mysql_result()</methodname> to
+          <methodname>raw_result()</methodname> so it&rsquo;s database
+          server neutral.</para></listitem>
+
+          <listitem><para>Removed
+          <methodname>ResUse::eof()</methodname>, as it wrapped
+          the deprecated and unnecessary MySQL C API function
+          <ulink url="mysql-eof" type="mysqlapi"/>. See the
+          <filename>simple3</filename> and <filename>usequery</filename>
+          examples to see the proper way to test for the end of a result
+          set.</para></listitem>
+
+        </itemizedlist>
+      </sect4>
+
+
+      <sect4 id="api-2.0.0-Row">
+        <title>Row class changes</title>
+
+        <itemizedlist>
+
+          <listitem><para>Removed &ldquo;field name&rdquo; form
+          of <methodname>Row::field_list()</methodname>. It was
+          pointless.</para></listitem>
+
+          <listitem><para><classname>Row</classname> subscripting
+          works more like v1.7.9: one can subscript a
+          <classname>Row</classname> with a string (e.g.
+          <methodname>row["myfield"]</methodname>), or with
+          an integer (e.g. <methodname>row[5]</methodname>).
+          <methodname>lookup_by_name()</methodname> was
+          removed. Because <methodname>row[0]</methodname> is
+          ambiguous (0 could mean the first field, or be a null
+          pointer to <type>const char*</type>), there is now
+          <methodname>Row::at()</methodname>, which can look up any
+          field by index.</para></listitem>
+
+        </itemizedlist>
+      </sect4>
+
+
+      <sect4 id="api-2.0.0-misc">
+        <title>Miscellaneous changes</title>
+
+        <itemizedlist>
+
+          <listitem><para>Where possible, all distributed Makefiles only
+          build dynamic libraries. (Shared objects on most Unices, DLLs
+          on Windows, etc.) Unless your program is licensed under the
+          GPL or LGPL, you shouldn&rsquo;t have been using the static
+          libraries from previous versions anyway.</para></listitem>
+
+          <listitem><para>Removed the backwards-compatibility
+          headers <filename>sqlplus.hh</filename> and
+          <filename>mysql++.hh</filename>. If you were
+          still using these, you will have to change to
+          <filename>mysql++.h</filename>, which will put all symbols in
+          <symbol>namespace mysqlpp</symbol>.</para></listitem>
+
+          <listitem><para>Can no longer use arrow operator
+          (<symbol>-></symbol>) on the iterators into the
+          <classname>Fields</classname>, <classname>Result</classname>
+          and <classname>Row</classname> containers.</para></listitem>
+
+        </itemizedlist>
+      </sect4>
+    </sect3>
+
+    <sect3 id="api-2.2.0">
+      <title>v2.2.0</title>
+
+      <para>Code like this will have to change:</para>
+
+      <programlisting>
+query &lt;&lt; "delete from mytable where myfield=%0:myvalue";
+query.parse();
+query.def["myvalue"] = some_value;
+query.execute();</programlisting>
+
+      <para>...to something more like this:</para>
+
+      <programlisting>
+query &lt;&lt; "delete from mytable where myfield=%0";
+query.parse();
+query.execute(some_value);</programlisting>
+
+      <para>The first code snippet abuses the default template query
+      parameter mechanism (<varname>Query::def</varname>) to fill out
+      the template instead of using one of the overloaded forms of
+      <methodname>execute()</methodname>,
+      <methodname>store()</methodname> or <methodname>use()</methodname>
+      taking one or more <classname>SQLString</classname> parameters.
+      The purpose of <varname>Query::def</varname> is to allow for
+      default template parameters over multiple queries. In the first
+      snippet above, there is only one parameter, so in order to justify
+      the use of template queries in the first place, it must be
+      changing with each query. Therefore, it isn&rsquo;t really a
+      &ldquo;default&rdquo; parameter at all. We did not make this
+      change maliciously, but you can understand why we are not in any
+      hurry to restore this &ldquo;feature&rdquo;.</para>
+
+      <para>(Incidentally, this change was made to allow better support
+      for BLOB columns.)</para>
+    </sect3>
+
+
+    <sect3 id="api-2.3.0">
+      <title>v2.3.0</title>
+
+      <para><methodname>Connection::set_option()</methodname> calls now
+      set the connection option immediately, instead of waiting until
+      just before the connnection is actually established. Code that
+      relied on the old behavior could see unhandled exceptions, since
+      option setting errors are now thrown from a different part of the
+      code. You want to wrap the actual
+      <methodname>set_option()</methodname> call now, not
+      <methodname>Connection::connect()</methodname></para>
+
+      <para><classname>FieldNames</classname> and
+      <classname>FieldTypes</classname> are no longer exported from the
+      library. If you are using these classes directly from Visual C++
+      or MinGW, your code won&rsquo;t be able to dynamically link to a
+      DLL version of the library any more. These are internal classes,
+      however, so no one should be using them directly.</para>
+    </sect3>
+
+
+    <sect3 id="api-3.0.0">
+      <title>v3.0.0</title>
+
+      <sect4 id="api-3.0.0-names">
+        <title>Class name changes</title>
+
+        <para>Several classes changed names in this
+        release:</para>
+
+        <itemizedlist>
+          <listitem><para><classname>ColData</classname> is now
+          <classname>String</classname>.</para></listitem>
+
+          <listitem><para><classname>NullisBlank</classname>
+          is now <classname>NullIsBlank</classname>. (Note
+          the capital <emphasis>I</emphasis>.) Similar
+          changes for <classname>NullisNull</classname> and
+          <classname>NullisZero</classname>.</para></listitem>
+
+          <listitem><para><classname>ResNSel</classname> is now
+          <classname>SimpleResult</classname>.</para></listitem>
+
+          <listitem><para><classname>Result</classname> is now
+          <classname>StoreQueryResult</classname>.</para></listitem>
+
+          <listitem><para><classname>ResUse</classname> is now
+          <classname>UseQueryResult</classname>.</para></listitem>
+
+          <listitem><para><classname>SQLString</classname> is now
+          <classname>SQLTypeAdapter</classname>.</para></listitem>
+        </itemizedlist>
+
+        <para>When first building existing code against this version,
+        you may find it helpful to define the macro
+        <varname>MYSQLPP_OLD_CLASS_NAMES</varname> in your
+        program&rsquo;s build options. This will turn on some macros
+        that set up aliases for the new class names matching their
+        corresponding old names. Then, when you&rsquo;ve fixed up any
+        other issues that may prevent your program from building with
+        the new MySQL++, you can turn it back off and fix up any class
+        name differences.</para>
+
+        <para>If you were only using <classname>ColData</classname> in a
+        BLOB context, you should use <classname>sql_blob</classname> or
+        one of the related typedefs defined in
+        <filename>lib/sql_types.h</filename> instead, to insulate your
+        code from changes like these.</para>
+
+        <para>The <classname>SQLString</classname> change
+        shouldn&rsquo;t affect you, as this class was not designed to be
+        used by end user code. But, due to the old name and the fact
+        that it used to derive from <classname>std::string</classname>,
+        some might have been tempted to use it as an enhanced
+        <classname>std::string</classname>. Such code will undoubtedly
+        break, but can probably be fixed by just changing it to use
+        <classname>std::string</classname> instead.</para>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-Connection">
+        <title>Connection class changes</title>
+
+        <para>The option setting mechanism has been redesigned. (Yes,
+        again.) There used to be an enum in
+        <classname>Connection</classname> with a value for each option
+        we understood, and an overload of
+        <methodname>Connection::set_option()</methodname> for each
+        argument type we understood. It was possible to pass any option
+        value to any <methodname>set_option()</methodname> overload, and
+        the problem would only be detected at run time. Now each option
+        is represented by a class derived from the new
+        <classname>Option</classname> abstract base class, and
+        <methodname>set_option()</methodname> simply takes a pointer to
+        one of these objects. See
+        <filename>examples/multiquery.cpp</filename> for the syntax.
+        Since each <classname>Option</classname> subclass takes only the
+        parameter types it actually understands, it&rsquo;s now
+        completely type-safe at compile time.</para>
+
+        <para>The new option setting mechanism also has the virtue of
+        being more powerful so it let us replace several existing things
+        within <classname>Connection</classname> with new
+        options:</para>
+
+        <itemizedlist>
+          <listitem><para>Replaced
+          <methodname>enable_ssl()</methodname> with
+          <classname>SslOption</classname>.</para></listitem>
+
+          <listitem><para>Replaced the <varname>compress</varname>
+          parameter to the <classname>Connection</classname>
+          create-and-connect constructor and
+          <methodname>Connection::connect()</methodname> method with
+          <classname>CompressOption</classname>.</para></listitem>
+
+          <listitem><para>Replaced the
+          <varname>connect_timeout</varname> parameter with
+          <classname>ConnectTimeoutOption</classname>.</para></listitem>
+
+          <listitem><para>Defined <classname>Option</classname>
+          subclasses for each of the flags you would previously set
+          using the <varname>client_flag</varname> parameter. There
+          are about a dozen of these, so instead of listing them,
+          look in <filename>lib/options.h</filename> for something
+          with a similar name.</para></listitem>
+        </itemizedlist>
+
+        <para>Collapsed <classname>Connection</classname>&rsquo;s
+        <varname>host</varname>, <varname>port</varname>, and
+        <varname>socket_name</varname> parameters down into a new
+        combined <varname>server</varname> parameter which is parsed to
+        determine what kind of connection you mean. These interfaces are
+        still compatible with v2.3 and earlier up through the port
+        parameter.</para>
+
+        <para>Moved
+        <methodname>Connection::affected_rows()</methodname>,
+        <methodname>info()</methodname> and
+        <methodname>insert_id()</methodname> methods to class
+        <classname>Query</classname>, as they relate to the most
+        recently-executed query.</para>
+
+        <para>Changed the return type of
+        <methodname>Connection::ping()</methodname> from
+        <type>int</type> to <type>bool</type>. If you were calling
+        <methodname>ping()</methodname> in <type>bool</type> context
+        or using its return value in <type>bool</type> context,
+        you will need to reverse the sense of the test because the
+        previous return code used zero to mean success. Now it returns
+        <type>true</type> to indicate success.</para>
+
+        <para>Renamed several methods:</para>
+
+        <itemizedlist>
+          <listitem><para>Use <methodname>client_version()</methodname>
+          instead of <methodname>api_version()</methodname> or
+          <methodname>client_info()</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>ipc_version()</methodname> instead of
+          <methodname>host_info()</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>protocol_version()</methodname> instead of
+          <methodname>proto_info()</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>server_version()</methodname> instead of
+          <methodname>server_info()</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>status()</methodname> instead of
+          <methodname>stat()</methodname>.</para></listitem>
+        </itemizedlist>
+
+        <para>Also, removed <methodname>close()</methodname> in favor
+        of <methodname>disconnect()</methodname>, which has always
+        done the same thing.</para>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-DateTime">
+        <title>Date and Time class changes</title>
+  
+        <para>The <type>sql_timestamp</type> typedef is now
+        an alias for <classname>DateTime</classname>, not
+        <classname>Time</classname>.</para>
+
+        <para>There used to be implicit conversion constructors from
+        <classname>ColData</classname> (now
+        <classname>String</classname>),
+        <classname>std::string</classname> and <type>const char*</type>
+        for the <classname>Date</classname>,
+        <classname>DateTime</classname>, and <classname>Time</classname>
+        classes. It&rsquo;s still possible to do these conversions, but
+        only explicitly. (This had to be done to make
+        <classname>Null&lt;T&gt;</classname> work in SSQLSes.)</para>
+
+        <para>The most likely place to run into problems as a result
+        of this change is in code like this:</para>
+
+        <programlisting>
+void some_function(const mysqlpp::DateTime&amp; dt);
+
+some_function("2007-12-22");</programlisting>
+
+        <para>The function call needs to be changed to:</para>
+
+        <programlisting>
+some_function(mysqlpp::DateTime("2007-12-22"));</programlisting>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-Exception">
+        <title>Exception changes</title>
+
+        <para>If an error occurs during the processing of a
+        &ldquo;use&rdquo; query (as opposed to the initial execution) we
+        throw the new <classname>UseQueryError</classname> exception
+        instead of <classname>BadQuery</classname>.</para>
+
+        <para>If you pass bad values to the <classname>Row</classname>
+        ctor so that it can&rsquo;t initialize itself properly, it
+        throws the <classname>ObjectNotInitialized </classname>
+        exception instead of <classname>BadQuery</classname>.</para>
+
+        <para>Together, these two changes mean that
+        <classname>BadQuery</classname> is now used solely to indicate
+        a problem executing the actual SQL query statement.</para>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-Field">
+        <title>Field and Fields class changes</title>
+
+        <para><classname>Field</classname> is now a real C++ class,
+        not just a typedef for the corresponding C API class. Major
+        portability impacts are:</para>
+
+        <itemizedlist>
+          <listitem><para>It has no public data members. Where
+          sensible, there is a public accessor function of the
+          same name as the corresponding field in the C API
+          structure.</para></listitem>
+
+          <listitem><para>The main exception to this is the
+          <varname>flags</varname> data member. This is a bitfield in
+          the C API data structure and you had to use MySQL-specific
+          constants to break values out of it. MySQL++&rsquo;s new
+          <classname>Field</classname> class provides a public member
+          function returning <type>bool</type> for each of these
+          flags.</para></listitem>
+
+          <listitem><para>The new class doesn&rsquo;t include all of the
+          data members from the C API version. We left out those that
+          aren&rsquo;t used within MySQL++ or its examples, or whose
+          function we couldn&rsquo;t understand. Basically, if we
+          couldn&rsquo;t document a reason to use it, we left it
+          out.</para></listitem>
+        </itemizedlist>
+
+        <para><classname>Fields</classname> used to be a
+        <classname>std::vector</classname> work-alike which
+        worked with the C API to access fields and return them
+        as though they were simply contained directly within the
+        <classname>Fields</classname> object. Now that we have a
+        real MySQL++ class to hold information about each field
+        without reference to the C API, we were able to replace the
+        <classname>Fields</classname> class with:</para>
+
+        <programlisting>
+typedef std::vector&lt;Field&gt; Fields;</programlisting>
+
+        <para>If anything, this should give a pure superset of the old
+        functionality, but it&rsquo;s possible it could break end user
+        code.</para>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-Query">
+        <title>Query class changes</title>
+
+        <para>If you were using <type>char</type> as an 8-bit integer
+        in query building, there are several places in MySQL++ v3 where
+        it will now be treated as a single-character string. MySQL++
+        has had the <classname>tiny_int</classname> class for many
+        years now specifically to provide a true 8-bit integer without
+        the semantic confusion surrounding the old C <type>char</type>
+        type. Either use <classname>tiny_int</classname>, or
+        use the SQL type aliases <type>sql_tinyint</type> and
+        <type>sql_tinyint_unsigned</type> instead.</para>
+
+        <para>The &lsquo;r&rsquo; and &lsquo;R&rsquo; template query
+        parameter modifiers were removed. They made the library do
+        quoting and both quoting and escaping (respectively) regardless
+        of the data type of the parameter. There are no corresponding
+        <classname>Query</classname> stream manipulators, so for
+        symmetery we had to decide whether to add such manipulators or
+        remove the tquery modifiers. There should never be a reason to
+        force quoting or escaping other than to work around a MySQL++
+        bug, and it&rsquo;s better to just fix the bug than work around
+        it, so removed the tquery modifiers.</para>
+
+        <para><methodname>Query::store_next()</methodname>
+        and <methodname>Result::fetch_row()</methodname> no
+        longer throw the <classname>EndOfResults</classname> and
+        <classname>EndOfResultSets</classname> exceptions; these
+        are not exceptional conditions! These methods simply return
+        <type>false</type> when you hit the end of the result set
+        now.</para>
+
+        <para>Renamed <varname>Query::def</varname> to
+        <varname>Query::template_defaults</varname> to make its
+        purpose clearer.</para>
+
+        <para>Removed <methodname>Query::preview()</methodname>.  The
+        most direct replacement for this set of overloaded methods is
+        the parallel set of <methodname>str()</methodname> methods,
+        which were just aliases before. (Chose
+        <methodname>str()</methodname> over
+        <methodname>preview()</methodname> because it&rsquo;s standard
+        C++ nomenclature.) But if you&rsquo;re just looking to get a
+        copy of a built query string and you aren&rsquo;t using template
+        queries, you can now insert the <classname>Query</classname>
+        into a stream and get the same result.</para>
+
+        <para>For example, a lot of code in the examples that used to
+        say things like:</para>
+
+        <programlisting>
+cout &lt;&lt; query.preview() &lt;&lt; endl;</programlisting>
+
+        <para>now looks like this:</para>
+        
+        <programlisting>
+cout &lt;&lt; query &lt;&lt; endl;</programlisting>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-Result">
+        <title>Result, ResUse, and ResNSel class changes</title>
+
+        <para>In addition to the class name changes described above,
+        <classname>UseQueryResult</classname> is no longer
+        <classname>StoreQueryResult</classname>&rsquo;s base class.
+        There is a new abstract class called
+        <classname>ResultBase</classname> containing much of what used
+        to be in <classname>ResUse</classname>, and it is the base of
+        both of these concrete result set types. This should only affect
+        your code if you were using <classname>ResUse</classname>
+        references to refer to <classname>Result</classname>
+        objects.</para>
+
+        <para>Removed a bunch of duplicate methods:</para>
+        
+        <itemizedlist>
+          <listitem><para>Use
+          <methodname>num_fields()</methodname> instead of
+          <methodname>columns()</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>field_names()</methodname> instead of
+          <methodname>names()</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>num_rows()</methodname> instead of
+          <methodname>rows()</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>field_types()</methodname> instead of
+          <methodname>types()</methodname>.</para></listitem>
+        </itemizedlist>
+
+        <para>Renamed several methods for &ldquo;grammar&rdquo; reasons.
+        For example, some methods returned a single object but had a
+        &ldquo;plural&rdquo; name, implying that it returned a container
+        of objects. In cases like this, we changed the name to agree
+        with the return value. Some of these also fall into the
+        duplicate method category above:</para>
+
+        <itemizedlist>
+          <listitem><para>Use
+          <methodname>field(unsigned int)</methodname>
+          instead of <methodname>fields(unsigned
+          int)</methodname>.</para></listitem>
+
+          <listitem><para>Use <methodname>field_num(const
+          std::string&amp;)</methodname>
+          instead of <methodname>names(const
+          std::string&amp;)</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>field_name(int)</methodname> instead of
+          <methodname>names(int)</methodname>.</para></listitem>
+
+          <listitem><para>Use
+          <methodname>field_type(int)</methodname> instead of
+          <methodname>types(int)</methodname>.</para></listitem>
+        </itemizedlist>
+
+        <para>Removed several &ldquo;smelly&rdquo; methods:</para>
+
+        <itemizedlist>
+          <listitem><para><methodname>purge()</methodname>: was an
+          internal implementation detail, not something for end user
+          code to call</para></listitem>
+
+          <listitem><para><methodname>raw_result()</methodname>: end
+          user code shouldn&rsquo;t be digging down to the C API data
+          structures, but if you really need something like this, look
+          at the implementation of
+          <methodname>Query::storein()</methodname>. Its workings will
+          probably be educational.</para></listitem>
+
+          <listitem><para><methodname>reset_names()</methodname>:
+          no reason to call this, especially now that the field
+          name list is initialized once at startup and then never
+          changed</para></listitem>
+
+          <listitem><para><methodname>reset_field_names()</methodname>:
+          just an alias for previous</para></listitem>
+
+          <listitem><para><methodname>reset_types()</methodname>:
+          same argument as for
+          <methodname>reset_names()</methodname></para></listitem>
+
+          <listitem><para><methodname>reset_field_types()</methodname>:
+          just an alias for previous</para></listitem>
+        </itemizedlist>
+
+        <para><methodname>ResUse::field_num()</methodname> would
+        unconditionally throw a <classname>BadFieldName</classname>
+        exception when you asked for a field that doesn&rsquo;t exist.
+        Now, if exceptions are disabled on the object, it just returns
+        -1.</para>
+
+        <para><classname>SimpleResult</classname>&rsquo;s member
+        variables are all now private, and have read-only accessor
+        functions of the same name.</para>
+
+        <para>Code like this used to work:</para>
+
+        <programlisting>
+mysqlpp::Row row;
+mysqlpp::Result::size_type i;
+for (i = 0; row = res[i]; ++i) {
+  // Do something with row here
+}</programlisting>
+
+        <para>That is, indexing past the end of a &ldquo;store&rdquo;
+        result set would just return an empty row object, which tests as
+        false in <type>bool</type> context, so it ends the loop. Now
+        that <classname>StoreQueryResult</classname> is a
+        <classname>std::vector</classname> derivative, this either
+        crashes your program or causes the standard library to throw an
+        exception, depending on what debugging features your version of
+        STL has. The proper technique is:</para>
+
+        <programlisting>
+mysqlpp::Row row;
+mysqlpp::Result::size_type i;
+for (i = 0; i &lt; res.num_rows(); ++i) {
+  row = res[i];
+  // Do something with row here
+}</programlisting>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-Row">
+        <title>Row class changes</title>
+
+        <para>Removed <methodname>Row::raw_data()</methodname>,
+        <methodname>raw_size()</methodname> and
+        <methodname>raw_string()</methodname>. These were useful with
+        BLOB data back when MySQL++ didn&rsquo;t handle embedded null
+        characters very well, and when copies of
+        <classname>ColData</classname> objects were expensive. Neither
+        is true now, so they have no value any more. Equivalent calls
+        are:</para>
+
+        <programlisting>
+mysqlpp::String s = row[0];
+s.data();                          // raw_data() equivalent
+s.length();                        // raw_size() equivalent
+std::string(s.data(), s.length()); // raw_string() equivalent</programlisting>
+
+        <para><methodname>Row::operator[](const char*)</methodname>
+        would unconditionally throw a
+        <classname>BadFieldName</classname> exception when you asked for
+        a field that doesn&rsquo;t exist. Now, if exceptions are
+        disabled on the <classname>Row</classname> object, it just
+        returns a reference to an empty <classname>String</classname>
+        object.  You can tell when this happens because such an object
+        tests as false in <type>bool</type> context.</para>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-SSQLS">
+        <title>Specialized SQL Structure (SSQLS) changes</title>
+
+        <para>Renamed <filename>custom*</filename> to
+        <filename>ssqls*</filename>. There is a backwards-compatibility
+        header <filename>custom.h</filename> which includes
+        <filename>ssqls.h</filename> for you, but it will go away in a
+        future version of MySQL++.</para>
+
+        <para>The only supported macros for creating
+        SSQLSes now are <function>sql_create_*</function>
+        and <function>sql_create_complete_*</function>. The
+        &ldquo;basic&rdquo; variants were removed because they&rsquo;re
+        less functional than <function>sql_create_*</function>, and
+        haven&rsquo;t been used in the examples or documentation for
+        a long time now. The other two methods were removed because
+        parameter ordering no longer matters so there&rsquo;s
+        no need for macros that let you have custom parameter
+        ordering. (It&rsquo;s more complicated than that, actually. See
+        the ChangeLog for the detailed whys and wherefores.)</para>
+
+        <para>The new <classname>Null&lt;T&gt;</classname> support in
+        SSQLSes causes an internal compiler error in Visual C++ 2003.
+        (VC++ 2005 and newer have no trobule with it.) A poll on the
+        mailing list says there aren&rsquo;t many people still stuck on
+        this version, so we just ifdef&rsquo;d out the SSQLS mechanism
+        and all the examples that use it when built with VC++ 2003.  If
+        this affects you, see <xref linkend="ssqls-vc2003"/> for
+        suggestions on ways to cope.</para>
+
+        <para>If you are using types other than MySQL++&rsquo;s
+        <type>sql_*</type> ones <footnote><para>These typedefs
+        have been available since MySQL++ v2.1.</para></footnote>
+        in your SSQLSes, code that previously worked may now see
+        <classname>TypeLookupFailed</classname> exceptions. (This
+        can be thrown even if exceptions are otherwise disabled in
+        MySQL++.) This version of MySQL++ is stricter about mapping
+        SQL to C++ type information, and vice versa. If the library
+        can&rsquo;t find a suitable mapping from one type system
+        to the other, it throws this exception, because its only
+        other option would be to crash or raise an assertion. This
+        typically happens when building SQL queries, so you can
+        probably handle it the same way as if the subsequent
+        query excecution failed. If you&rsquo;re catching the
+        generic <classname>mysqlpp::Exception</classname>, your
+        error handling code might not need to change. If you see
+        this exception, it does mean you need to look into your
+        use of data types, though. The table that controls this is
+        <varname>mysql_type_info::types</varname>, defined at the top
+        of <filename>lib/type_info.cpp</filename>. Every data type in
+        <filename>lib/sql_types.h</filename> has a corresponding record
+        in this table, so if you stick to those types, you&rsquo;ll
+        be fine. It&rsquo;s also okay to use types your C++ compiler
+        can convert directly to these predefined types.</para>
+
+        <para>The <varname>_table</varname> static member variable
+        for each SSQLS is now private. The recommended way to access
+        this remains unchanged: the <function>table()</function>
+        static member function.</para>
+
+        <para><function>table()</function> used to return a modifiable
+        reference to the table name. Now there are two overloads,
+        one which returns an unmodifiable pointer to the table name,
+        and the other which takes <type>const char*</type> so you
+        can override the default table name. So, the code we used to
+        recommend for changing the SSQLS&rsquo;s table name:</para>
+
+        <programlisting>
+my_ssqls_type::table() = "MyTableName";</programlisting>
+
+        <para>now needs to be:</para>
+
+        <programlisting>
+my_ssqls_type::table("MyTableName");</programlisting>
+      </sect4>
+
+
+      <sect4 id="api-3.0.0-misc">
+        <title>Miscellaneous changes</title>
+
+        <para>MySQL++ does quoting and escaping much more selectively
+        now. Basically, if the library can tell you&rsquo;re not
+        building a SQL query using one of the standard methods, it
+        assumes you&rsquo;re outputting values for human consumption, so
+        it disables quoting and SQL escaping. If you need to build your
+        own mechanism to replace this, quoting is easy to do, and
+        <methodname>Query::escape_string()</methodname> can do SQL
+        escaping for you.</para>
+
+        <para>Removed <methodname>success()</methodname> in
+        <classname>Connection</classname>, <classname>Query</classname>
+        and <classname>SimpleResult</classname> (neƩ
+        <classname>ResNSel</classname>) and simply made these classes
+        testable in <type>bool</type> context to get the same
+        information. An additional change in
+        <classname>Connection</classname> is that it used to be
+        considered &ldquo;unsuccessful&rdquo; when the connection was
+        down. Since the sense of this test is now whether the object is
+        in a good state, it only returns <type>false</type> when the
+        connection attempt fails. Call
+        <methodname>Connection::is_connected()</methodname> if you just
+        want to test whether the connection is up.</para>
+
+        <para>The debug mode build of the library now has a "_d" suffix
+        for Visual C++, and Xcode. This lets you have both versions
+        installed without conflict. The release build uses the current
+        naming scheme. If you have an existing program building against
+        MySQL++ on these platforms, you&rsquo;ll need to change your
+        build options to use the new name in debug mode.</para>
+
+        <para>Renamed <varname>NO_LONG_LONGS</varname> to
+        <varname>MYSQLPP_NO_LONG_LONGS</varname> to avoid a risk of
+        collision in the global macro namespace.</para>
+      </sect4>
+    </sect3>
+  </sect2>
+
+
+  <sect2 id="abi-changes">
+    <title>ABI Changes</title>
+
+    <para>This section documents those library changes that require you
+    to rebuild your program so that it will link with the new library.
+    Most of the items in the previous section are also ABI changes, but
+    this section is only for those items that shouldn&rsquo;t require
+    any code changes in your program.</para>
+
+    <para>If you were going to rebuild your program after
+    installing the new library anyway, you can probably ignore this
+    section.</para>
+
+
+    <sect3 id="abi-1.7.18">
+      <title>v1.7.18</title>
+
+      <para>The <classname>Query</classname> classes now subclass from
+      <classname>stringstream</classname> instead of the deprecated
+      <classname>strstream</classname>.</para>
+    </sect3>
+
+
+    <sect3 id="abi-1.7.19">
+      <title>v1.7.19</title>
+
+      <para>Fixed several <type>const</type>-incorrectnesses in the
+      <classname>Query</classname> classes.</para>
+    </sect3>
+
+
+    <sect3 id="abi-1.7.22">
+      <title>v1.7.22</title>
+
+      <para>Removed &ldquo;reset query&rdquo; parameters from several
+      <classname>Query</classname> class members. This is not an API
+      change, because the parameters were given default values, and the
+      library would ignore any value other than the default. So, any
+      program that tried to make them take another value wouldn&rsquo;t
+      have worked anyway.</para>
+    </sect3>
+
+
+    <sect3 id="abi-1.7.24">
+      <title>v1.7.24</title>
+
+      <para>Some freestanding functions didn&rsquo;t get moved into
+      <symbol>namespace mysqlpp</symbol> when that namespace was
+      created. This release fixed that. It doesn&rsquo;t affect the API
+      if your program&rsquo;s C++ source files say <symbol>using
+      namespace mysqlpp</symbol> within them.</para>
+    </sect3>
+
+
+    <sect3 id="abi-2.0.0">
+      <title>v2.0.0</title>
+
+      <para>Removed <methodname>Connection::infoo()</methodname>.
+      (I&rsquo;d call this an API change if I thought there were any
+      programs out there actually using this...)</para>
+
+      <para>Collapsed the <classname>Connection</classname> constructor
+      taking a bool (for setting the throw_exceptions flag) and the
+      default constructor into a single constructor using a default for
+      the parameter.</para>
+
+      <para>Classes <classname>Connection</classname> and
+      <classname>Query</classname> are now derived from the
+      <classname>Lockable</classname> interface, instead of implementing
+      their own lock/unlock functions.</para>
+
+      <para>In several instances, functions that took objects by
+      value now take them by const reference, for efficiency.</para>
+
+      <para>Merged <classname>SQLQuery</classname> class&rsquo;s members
+      into class <classname>Query</classname>.</para>
+
+      <para>Merged <classname>RowTemplate</classname> class&rsquo;s
+      members into class <classname>Row</classname>.</para>
+
+      <para>Reordered member variable declarations in some classes. The
+      most common instance is when the private section was declared
+      before the public section; it is now the opposite way. This
+      can change the object&rsquo;s layout in memory, so a program
+      linking to the library must be rebuilt.</para>
+
+      <para>Simplified the date and time class hierarchy.
+      <ulink type="structref" url="Date"/> used to
+      derive from <classname>mysql_date</classname>,
+      <ulink type="structref" url="Time"/> used to derive
+      from <classname>mysql_time</classname>, and <ulink
+      type="structref" url="DateTime"/> used to derive from
+      both of those.  All three of these classes used to derive
+      from <classname>mysql_dt_base</classname>.  All of the
+      <classname>mysql_*</classname> classes&rsquo; functionality
+      and data has been folded into the leaf classes, and now the
+      only thing shared between them is their dependence on the
+      <ulink type="structref" url="DTbase"/> template. Since the
+      leaf classes&rsquo; interface has not changed and end-user
+      code shouldn&rsquo;t have been using the other classes, this
+      shouldn&rsquo;t affect the API in any practical way.</para>
+
+      <para><classname>mysql_type_info</classname> now always
+      initializes its private <varname>num</varname> member.
+      Previously, this would go uninitialized if you used the default
+      constructor. Now there is no default ctor, but the ctor taking one
+      argument (which sets <varname>num</varname>) has a default.</para>
+    </sect3>
+
+
+    <sect3 id="abi-3.0.0">
+      <title>v3.0.0</title>
+
+      <para>Removed <varname>reset_query</varname> parameters from
+      <classname>Query</classname> member functions. None of these have
+      been honored at least going back to v1.7.9, so this is not an API
+      change. As of this version, <classname>Query</classname> now
+      automatically detects when it can safely reset itself after
+      executing a query, so it&rsquo;s not necessary to ask for a reset
+      except when using template queries.</para>
+
+      <para>Removed overloads of
+      <methodname>Query::execute()</methodname>,
+      <methodname>store()</methodname>, and
+      <methodname>use()</methodname> that take only a <type>const
+      char*</type>. This is not an API change because there was an
+      equivalent call chain for this already. This change just snaps
+      a layer of indirection.</para>
+
+      <para><methodname>Query::error()</methodname> is now
+      <type>const</type> and returns <type>const char*</type> instead
+      of a <classname>std::string</classname> by value.</para>
+
+      <para>Removed <classname>Lockable</classname> mechanism as it was
+      conceptually flawed. <classname>Connection</classname> and
+      <classname>Query</classname> consequently no longer derive from
+      <classname>Lockable</classname>. Since it was basically useless in
+      prior versions, it can&rsquo;t be construed as an API
+      change.</para>
+    </sect3>
+
+
+    <sect3 id="abi-3.0.1">
+      <title>v3.0.1</title>
+
+      <para><methodname>Connection::thread_aware()</methodname>,
+      <methodname>thread_start()</methodname> and
+      <methodname>thread_end()</methodname> are now static methods, so
+      a program can call them before creating a connection. Ditto for
+      <classname>DBDriver</classname> methods of the same name.</para>
+
+      <para><methodname>ConnectionPool::release()</methodname> is now
+      virtual, so a subclass can override it.</para>
+    </sect3>
+
+
+    <sect3 id="abi-3.0.2">
+      <title>v3.0.2</title>
+
+      <para><methodname>ConnectionPool::grab()</methodname> is now
+      virtual; same reason as above.</para>
+
+      <para><classname>Query</classname> can now be tested in
+      <type>bool</type> context, as was intended for v3.0.0. Had to
+      change the &ldquo;safe bool&rdquo; method signature to make it
+      happen, so technically it&rsquo;s an API change, but it&rsquo;s
+      still used the same way.</para>
+    </sect3>
+  </sect2>
+</sect1>

ADDED   doc/userman/common.xsl
Index: doc/userman/common.xsl
==================================================================
--- /dev/null
+++ doc/userman/common.xsl
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- XSL stylesheet containing things common to both HTML and FO
+     transformations. -->
+
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+	<xsl:param name="section.autolabel" select="1"/>
+	<xsl:param name="section.autolabel.max.depth" select="2"/>
+	<xsl:param name="toc.section.depth" select="2"/>
+</xsl:stylesheet>
+

ADDED   doc/userman/configuration.dbx
Index: doc/userman/configuration.dbx
==================================================================
--- /dev/null
+++ doc/userman/configuration.dbx
@@ -0,0 +1,147 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="configuration">
+  <title>Configuring MySQL++</title>
+
+  <para>The default configuration of MySQL++ is suitable for most
+  purposes, but there are a few things you can change to make it meet
+  special needs.</para>
+
+  <sect2 id="mysql-loc">
+    <title>The Location of the MySQL Development Files</title>
+
+    <para>MySQL++ is built on top of the MySQL C API. It relies on
+    this low-level library for all communication with the database
+    server. Consequently, the build process for MySQL++ may fail if
+    it can&rsquo;t find the C API headers and library.</para>
+
+    <para>On platforms that use Autoconf<footnote><para>Linux,
+    Solaris, the BSDs, Mac OS X command line (as opposed to the
+    Xcode IDE), Cygwin... Basically, Unix or anything that works
+    like it.</para></footnote>, the <filename>configure</filename>
+    script can usually figure out the location of the C API
+    development files by itself. It simply tries a bunch of common
+    installation locations until it finds one that works. If
+    your MySQL server was installed in a nonstandard location,
+    you will have to tell the <filename>configure</filename>
+    script where these files are with some combination
+    of the <computeroutput>--with-mysql</computeroutput>,
+    <computeroutput>--with-mysql-include</computeroutput>, and
+    <computeroutput>--with-mysql-lib</computeroutput> flags. See
+    <filename>README-Unix.txt</filename> for details.</para>
+
+    <para>No other platform allows this sort of auto-discovery,
+    so the build files for these platforms simply hard-code the
+    default installation location for the current Generally
+    Available version of MySQL. For example, the Visual C++
+    project files currently assume MySQL is in <filename>c:\Program
+    Files\MySQL\MySQL Server 5.0</filename>. If you&rsquo;re using
+    some other release of MySQL or you installed it in a nonstandard
+    location, you will have to modify the build files.  How you do
+    this, exactly, varies based on platform and what tools you have
+    on hand. See <filename>README-Visual-C++.txt</filename>,
+    <filename>README-MinGW.txt</filename>, or
+    <filename>README-Mac-OS-X.txt</filename>, as appropriate.</para>
+  </sect2>
+
+
+  <sect2 id="max-columns">
+    <title>The Maximum Number of Columns Allowed</title>
+
+    <para>MySQL++ offers two ways to automatically build SQL
+    queries at run time: <xref linkend="tquery"/> and <xref
+    linkend="ssqlsintro"/>. There&rsquo;s a limit on the number
+    of template query parameters and the number of SSQLS fields,
+    due to the way these mechanisms work. Both are set to 25,
+    by default. We arrived at these limits empirically, partly by
+    looking at good database designs, and by testing compilers to
+    find their limits. We wanted a limit that doesn&rsquo;t often
+    need to be raised without unduly narrowing the list of supported
+    platforms by exceeding compiler limits.</para>
+
+    <para>If it happens that your database design does need more than
+    25 columns or template query parameters, first look to see if
+    there&rsquo;s a good way to change the design. It&rsquo;s usually
+    a sign of too many unrelated things in one table if you need so
+    many columns. If you decide the design is good, you can raise these
+    limits by re-generating the <filename>lib/ssqls.h</filename> and/or
+    <filename>lib/querydef.h</filename> headers using Perl scripts with
+    the same name, except with a <filename>pl</filename> extension.
+    Instructions for this are at the top of each script.</para>
+
+    <para>If you&rsquo;re on a platform that uses
+    Autoconf<footnote><para>ditto</para></footnote>, you can change
+    these scripts like you would any other part of the library. After
+    making your changes, just say <command>make</command> to rebuild
+    the library, including these headers. This requires a Perl
+    interpreter on the system to work, but Perl is nearly ubiquitous
+    on systems that also use autoconf these days.</para>
+
+    <para>On all other platforms, you&rsquo;ll have to rebuild
+    these headers by running Perl by hand. Just say <command>perl
+    ssqls.pl</command> or <command>perl querydef.pl</command> in the
+    <filename>lib</filename> subdirectory of the MySQL++ sources,
+    then build the library as you normally would.</para>
+  </sect2>
+
+
+  <sect2 id="buried-headers">
+    <title>Buried MySQL C API Headers</title>
+
+    <para>It&rsquo;s common these days on Unixy systems to install
+    the MySQL C API headers in a <filename>mysql</filename> directory
+    under some common <filename>include</filename> directory. If the
+    C API headers are in <filename>/usr/include/mysql</filename>, we
+    say they are &ldquo;buried&rdquo; underneath the system&rsquo;s
+    main include directory, <filename>/usr/include</filename>. Since
+    the MySQL++ headers depend on these C API headers, it can be
+    useful for MySQL++ to know this fact.</para>
+
+    <para>When MySQL++ includes one of the C API headers, it normally
+    does so in the obvious way:</para>
+
+    <programlisting>
+#include &lt;mysql.h&gt;
+</programlisting>
+
+    <para>But, if you define the
+    <varname>MYSQLPP_MYSQL_HEADERS_BURIED</varname> macro, it switches
+    to this style:</para>
+
+    <programlisting>
+#include &lt;mysql/mysql.h&gt;
+</programlisting>
+
+    <para>In common situations like the
+    <filename>/usr/include/mysql</filename> one, this simplifies the
+    include path options you pass to your compiler.</para>
+  </sect2>
+
+
+  <sect2 id="c99">
+    <title>Building MySQL++ on Systems Without Complete C99
+    Support</title>
+
+    <para>MySQL++ uses the <ulink
+    url="http://en.wikipedia.org/wiki/C_(programming_language)#C99">C99</ulink>
+    header <filename>stdint.h</filename> for portable fixed-size
+    integer typedefs where possible. The C99 extensions aren&rsquo;t
+    yet officially part of the C++ Standard, so there are still
+    some C++ compilers that don&rsquo;t offer this header. MySQL++
+    works around the lack of this header where it knows it needs
+    to, but your platform might not be recognized, causing
+    the build to break. If this happens, you can define the
+    <varname>MYSQLPP_NO_STDINT_H</varname> macro to make MySQL++
+    use its best guess for suitable integer types instead of relying
+    on <filename>stdint.h</filename>.</para>
+
+    <para>MySQL++ also uses C99&rsquo;s <type>long long</type>
+    data type where available. MySQL++ has workarounds for platforms
+    where this is known not to be available, but if you get errors in
+    <filename>common.h</filename> about this type, you can define the
+    macro <varname>MYSQLPP_NO_LONG_LONGS</varname> to make MySQL++
+    fall back to portable constructs.</para>
+  </sect2>
+</sect1>

ADDED   doc/userman/fo.xsl
Index: doc/userman/fo.xsl
==================================================================
--- /dev/null
+++ doc/userman/fo.xsl
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- XSL stylesheet containing additions to the standard DocBook
+     XSL-FO stylesheet.
+-->
+
+<xsl:stylesheet
+		xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+		xmlns:fo="http://www.w3.org/1999/XSL/Format"
+		version="1.0">
+	
+	<!-- Import the standard DocBook stylesheet that this one is based on.
+	     We use a web URL, but the local XML catalog should resolve this to
+			 the local copy of the stylesheet, if it exists. -->
+	<xsl:import href="http://docbook.sourceforge.net/release/xsl/current/fo/docbook.xsl"/>
+
+	<!-- Bring in local changes common to both HTML and FO output -->
+	<xsl:include href="common.xsl"/>
+
+	<!-- Add page breaks before each sect1, and define a processing
+	     instruction that will let us add additional hard breaks when
+			 needed.  From "DocBook XSL: The Complete Guide" 3/e -->
+	<xsl:attribute-set name="section.level1.properties">
+		<xsl:attribute name="break-before">page</xsl:attribute>
+	</xsl:attribute-set>
+	<xsl:template match="processing-instruction('hard-pagebreak')">
+		<fo:block break-before='page'/>
+	</xsl:template>
+
+	<!-- Suppress ulinks from the DocBook from making hyperlinks in the
+	  PDF, because most of them are relative links to the refman, and
+	  these don't work correctly within a PDF.  If you want cross-links,
+	  use the HTML manuals.  This code is from Bob Stayton, on the
+	  docbook-apps mailing list. -->
+	<xsl:template match="ulink" name="ulink">
+		<xsl:choose>
+			<xsl:when test="count(child::node())=0">
+				<xsl:call-template name="hyphenate-url">
+					<xsl:with-param name="url" select="@url"/>
+				</xsl:call-template>
+			</xsl:when>
+			<xsl:otherwise>
+				<xsl:apply-templates/>
+			</xsl:otherwise>
+		</xsl:choose> 
+	</xsl:template>
+
+	<!-- Disable hyphenation.  The hyphenation patterns aren't installed
+	     as part of FOP, and we don't want it anyway. -->
+	<xsl:template name="set.flow.properties">
+		<xsl:attribute name="hyphenate">false</xsl:attribute>
+	</xsl:template>
+
+	<!-- Rag-right lines -->
+	<xsl:attribute-set name="root.properties">
+		<xsl:attribute name="text-align">left</xsl:attribute>
+	</xsl:attribute-set>
+
+	<!-- Use a smaller font for code listings to increase the chances
+	     that they can fit on a single sheet, to reduce FOP complaints
+			 about being forced to split a listing across pages. -->
+	<xsl:attribute-set name="monospace.verbatim.properties">
+		<xsl:attribute name="font-size">85%</xsl:attribute>
+	</xsl:attribute-set>
+
+	<!-- Turn on extensions in DocBook stylesheets which make it use
+	     code that FOP 0.9x likes better.  Doesn't affect anything with
+			 the 1.69.1 stylesheets we're using on EL5, but is said to help
+			 with 1.72 at least. -->
+	<xsl:param name="fop1.extensions" select="1"/>
+</xsl:stylesheet>

ADDED   doc/userman/html.xsl
Index: doc/userman/html.xsl
==================================================================
--- /dev/null
+++ doc/userman/html.xsl
@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- XSL stylesheet containing additions to the standard DocBook
+     chunked-HTML stylesheet.
+-->
+
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+		version="1.0">
+	
+	<!-- Import the standard DocBook stylesheet that this one is based on.
+	     We use a web URL, but the local XML catalog should resolve this to
+			 the local copy of the stylesheet, if it exists. -->
+	<xsl:import href="http://docbook.sourceforge.net/release/xsl/current/html/chunk.xsl"/>
+
+	<!-- Bring in local changes common to both HTML and FO output -->
+	<xsl:include href="common.xsl"/>
+
+	<!-- HTML-specific XSL parameters -->
+	<xsl:param name="chunk.fast" select="0"/>
+	<xsl:param name="html.stylesheet" select="'tangentsoft.css'"/>
+	<xsl:param name="use.id.as.filename" select="1"/>
+
+	<!-- Special ulink types, to reduce boilerplate link code -->
+	<xsl:template match="ulink" name="refman_ulink">
+		<xsl:choose>
+			<!-- type=mysqlapi: makes hyperlinks to MySQL C API reference manual,
+			     given only the function name with dashes instead of underscores
+					 as the URL. -->
+			<xsl:when test="@type = 'mysqlapi'">
+				<tt>
+					<a>
+						<xsl:variable name="fn_dash" select="@url"/>
+						<xsl:variable name="fn_name"
+							select="translate($fn_dash, '-', '_')"/>
+						<xsl:attribute name="href">
+							<xsl:text>http://dev.mysql.com/doc/mysql/en/</xsl:text>
+							<xsl:value-of select="$fn_dash"/>
+							<xsl:text>.html</xsl:text>
+						</xsl:attribute>
+						<xsl:value-of select="$fn_name"/>
+						<xsl:text>()</xsl:text>
+					</a>
+				</tt>
+			</xsl:when>
+
+			<!-- type=classref: makes hyperlinks to a class in the MySQL++
+			     reference manual, given its name. -->
+			<xsl:when test="@type = 'classref'">
+				<tt>
+					<a>
+						<xsl:attribute name="href">
+							<xsl:text>../refman/classmysqlpp_1_1</xsl:text>
+							<xsl:value-of select="@url"/>
+							<xsl:text>.html</xsl:text>
+						</xsl:attribute>
+						<xsl:choose>
+							<xsl:when test="count(child::node())=0">
+								<xsl:value-of select="@url"/>
+							</xsl:when>
+							<xsl:otherwise>
+								<xsl:apply-templates/>
+							</xsl:otherwise>
+						</xsl:choose>
+					</a>
+				</tt>
+			</xsl:when>
+
+			<!-- type=structref: makes hyperlinks to a struct in the MySQL++
+			     reference manual, given its name. -->
+			<xsl:when test="@type = 'structref'">
+				<tt>
+					<a>
+						<xsl:attribute name="href">
+							<xsl:text>../refman/structmysqlpp_1_1</xsl:text>
+							<xsl:value-of select="@url"/>
+							<xsl:text>.html</xsl:text>
+						</xsl:attribute>
+						<xsl:choose>
+							<xsl:when test="count(child::node())=0">
+								<xsl:value-of select="@url"/>
+							</xsl:when>
+							<xsl:otherwise>
+								<xsl:apply-templates/>
+							</xsl:otherwise>
+						</xsl:choose>
+					</a>
+				</tt>
+			</xsl:when>
+
+			<xsl:otherwise>
+				<xsl:call-template name="ulink"/>
+			</xsl:otherwise>
+		</xsl:choose>
+	</xsl:template>
+</xsl:stylesheet>

ADDED   doc/userman/intro.dbx
Index: doc/userman/intro.dbx
==================================================================
--- /dev/null
+++ doc/userman/intro.dbx
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="intro">
+  <title>Introduction</title>
+
+  <para>MySQL++ is a powerful C++ wrapper for MySQL&rsquo;s C API.  Its
+  purpose is to make working with queries as easy as working with STL
+  containers.</para>
+
+  <para>The latest version of MySQL++ can be found at <ulink
+  url="http://tangentsoft.net/mysql++/">the official web
+  site</ulink>.</para>
+
+  <para>Support for MySQL++ can be had on <ulink
+  url="http://lists.mysql.com/plusplus">the mailing list</ulink>. That
+  page hosts the mailing list archives, and tells you how you can
+  subscribe.</para>
+
+
+  <sect2 id="history">
+    <title>A Brief History of MySQL++</title>
+
+    <para>MySQL++ was created in 1998 by Kevin Atkinson. It started out
+    MySQL-specific, but there were early efforts to try and make it
+    database-independent, and call it SQL++. This is where the old
+    library name &ldquo;sqlplus&rdquo; came from. This is also why the
+    old versions prefixed some class names with &ldquo;Mysql&rdquo; but
+    not others: the others were supposed to be the database-independent
+    parts.</para>
+
+    <para>Then in 1999, Sinisa Milivojevic unofficially took over
+    maintenance of the library, releasing versions 1.0 and 1.1. (All of
+    Kevin&rsquo;s releases were pre-1.0 point releases.) Kevin gave over
+    maintenance to Sinisa officially with 1.2, and ceased to have any
+    involvement with the library&rsquo;s maintenance. Sinisa went on to
+    maintain the library through 1.7.9, released in mid-2001. Since
+    Sinisa is an employee of <ulink url="http://www.mysql.com/">MySQL
+    AB</ulink>, it seems to be during this time that the dream of
+    multiple-database compatibility died.</para>
+
+    <para>With version 1.7.9, MySQL++ went into a period of stasis,
+    lasting over three years. During this time, Sinisa ran the
+    MySQL++ mailing list and supported its users, but made no new
+    releases. There were many patches submitted during this period,
+    some of which were ignored, others which were just put on the
+    MySQL++ web site for people to try. A lot of these patches were
+    mutually-incompatible, and not all of them gave a fully-functional
+    copy of MySQL++.</para>
+
+    <para>In early August of 2004, the current maintainer (Warren
+    Young) got fed up with this situation and took over. He released
+    1.7.10 later that month.</para>
+  </sect2>
+
+
+  <sect2 id="asking-questions">
+    <title>If You Have Questions...</title>
+
+    <para>If you want to email someone to ask questions about
+    this library, we greatly prefer that you send mail to the
+    <ulink url="http://lists.mysql.com/plusplus">MySQL++ mailing
+    list</ulink>. The mailing list is archived, so if you have
+    questions, do a search to see if the question has been asked
+    before.</para>
+
+    <para>You may find people&rsquo;s individual email addresses in various
+    files within the MySQL++ distribution. Please do not send mail
+    to them unless you are sending something that is inherently
+    personal. Not all of the principal developers of MySQL++ are still
+    active in its development; those who have dropped out have no wish
+    to be bugged about MySQL++. Those of us still active in MySQL++
+    development monitor the mailing list, so you aren&rsquo;t getting any
+    extra &ldquo;coverage&rdquo; by sending messages to additional
+    email addresses.</para>
+  </sect2>
+</sect1>

ADDED   doc/userman/licenses.dbx
Index: doc/userman/licenses.dbx
==================================================================
--- /dev/null
+++ doc/userman/licenses.dbx
@@ -0,0 +1,685 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="licenses">
+  <title>Licensing</title>
+
+  <para>The primary copyright holders on the MySQL++ library and its
+  documentation are Kevin Atkinson (1998), MySQL AB (1999 through 2001)
+  and Educational Technology Resources, Inc. (2004 through the date of
+  this writing). There are other contributors, who also retain
+  copyrights on their additions; see the ChangeLog file in the MySQL++
+  distribution tarball for details.</para>
+
+  <para>The MySQL++ library and its Reference Manual are released under
+  the GNU Lesser General Public License (LGPL), reproduced below.</para>
+
+  <para>The MySQL++ User Manual &mdash; excepting some example code from
+  the library reproduced within it &mdash; is offered under a license
+  closely based on the Linux Documentation Project License (LDPL) v2.0,
+  included below. (The MySQL++ documentation isn&rsquo;t actually part
+  of the Linux Documentation Project, so the main changes are to
+  LDP-related language. Also, generic language such as
+  &ldquo;author&rsquo;s (or authors&rsquo;)&rdquo; has been replaced
+  with specific language, because the license applies to only this one
+  document.)</para>
+
+  <para>These licenses basically state that you are free to use,
+  distribute and modify these works, whether for personal or commercial
+  purposes, as long as you grant the same rights to those you distribute
+  the works to, whether you changed them or not. See the licenses below
+  for full details.</para>
+
+
+  <?hard-pagebreak?>
+  <sect2 id="lgpl">
+    <title>GNU Lesser General Public License</title>
+    <subtitle>Version 2.1, February 1999</subtitle>
+
+    <para>Copyright (C) 1991, 1999 Free Software Foundation, Inc.  59
+    Temple Place, Suite 330, Boston, MA  02111-1307  USA Everyone is
+    permitted to copy and distribute verbatim copies of this license
+    document, but changing it is not allowed.</para>
+
+    <para>[This is the first released version of the Lesser GPL.  It
+    also counts as the successor of the GNU Library Public License,
+    version 2, hence the version number 2.1.]</para>
+
+    <sect3 id="lgpl-preamble">
+      <title>Preamble</title>
+
+      <para>The licenses for most software are designed to take away
+      your freedom to share and change it.  By contrast, the GNU General
+      Public Licenses are intended to guarantee your freedom to share
+      and change free software--to make sure the software is free for
+      all its users.</para>
+
+      <para>This license, the Lesser General Public License, applies to
+      some specially designated software packages--typically
+      libraries--of the Free Software Foundation and other authors who
+      decide to use it.  You can use it too, but we suggest you first
+      think carefully about whether this license or the ordinary General
+      Public License is the better strategy to use in any particular
+      case, based on the explanations below.</para>
+
+      <para>When we speak of free software, we are referring to freedom
+      of use, not price.  Our General Public Licenses are designed to
+      make sure that you have the freedom to distribute copies of free
+      software (and charge for this service if you wish); that you
+      receive source code or can get it if you want it; that you can
+      change the software and use pieces of it in new free programs; and
+      that you are informed that you can do these things.</para>
+
+      <para>To protect your rights, we need to make restrictions that
+      forbid distributors to deny you these rights or to ask you to
+      surrender these rights.  These restrictions translate to certain
+      responsibilities for you if you distribute copies of the library
+      or if you modify it.</para>
+
+      <para>For example, if you distribute copies of the library,
+      whether gratis or for a fee, you must give the recipients all the
+      rights that we gave you.  You must make sure that they, too,
+      receive or can get the source code.  If you link other code with
+      the library, you must provide complete object files to the
+      recipients, so that they can relink them with the library after
+      making changes to the library and recompiling it.  And you must
+      show them these terms so they know their rights.</para>
+
+      <para>We protect your rights with a two-step method: (1) we
+      copyright the library, and (2) we offer you this license, which
+      gives you legal permission to copy, distribute and/or modify the
+      library.</para>
+
+      <para>To protect each distributor, we want to make it very clear
+      that there is no warranty for the free library.  Also, if the
+      library is modified by someone else and passed on, the recipients
+      should know that what they have is not the original version, so
+      that the original author&rsquo;s reputation will not be affected
+      by problems that might be introduced by others.</para>
+
+      <para>Finally, software patents pose a constant threat to the
+      existence of any free program.  We wish to make sure that a
+      company cannot effectively restrict the users of a free program by
+      obtaining a restrictive license from a patent holder.  Therefore,
+      we insist that any patent license obtained for a version of the
+      library must be consistent with the full freedom of use specified
+      in this license.</para>
+
+      <para>Most GNU software, including some libraries, is covered by
+      the ordinary GNU General Public License.  This license, the GNU
+      Lesser General Public License, applies to certain designated
+      libraries, and is quite different from the ordinary General Public
+      License.  We use this license for certain libraries in order to
+      permit linking those libraries into non-free programs.</para>
+
+      <para>When a program is linked with a library, whether statically
+      or using a shared library, the combination of the two is legally
+      speaking a combined work, a derivative of the original library.
+      The ordinary General Public License therefore permits such linking
+      only if the entire combination fits its criteria of freedom.  The
+      Lesser General Public License permits more lax criteria for
+      linking other code with the library.</para>
+
+      <para>We call this license the &ldquo;Lesser&rdquo; General Public
+      License because it does Less to protect the user&rsquo;s freedom
+      than the ordinary General Public License.  It also provides other
+      free software developers Less of an advantage over competing
+      non-free programs.  These disadvantages are the reason we use the
+      ordinary General Public License for many libraries.  However, the
+      Lesser license provides advantages in certain special
+      circumstances.</para>
+
+      <para>For example, on rare occasions, there may be a special need
+      to encourage the widest possible use of a certain library, so that
+      it becomes a de-facto standard.  To achieve this, non-free
+      programs must be allowed to use the library.  A more frequent case
+      is that a free library does the same job as widely used non-free
+      libraries.  In this case, there is little to gain by limiting the
+      free library to free software only, so we use the Lesser General
+      Public License.</para>
+
+      <para>In other cases, permission to use a particular library in
+      non-free programs enables a greater number of people to use a
+      large body of free software.  For example, permission to use the
+      GNU C Library in non-free programs enables many more people to use
+      the whole GNU operating system, as well as its variant, the
+      GNU/Linux operating system.</para>
+
+      <para>Although the Lesser General Public License is Less
+      protective of the users&rsquo; freedom, it does ensure that the
+      user of a program that is linked with the Library has the freedom
+      and the wherewithal to run that program using a modified version
+      of the Library.</para>
+
+      <para>The precise terms and conditions for copying, distribution
+      and modification follow.  Pay close attention to the difference
+      between a &ldquo;work based on the library&rdquo; and a
+      &ldquo;work that uses the library&rdquo;.  The former contains
+      code derived from the library, whereas the latter must be combined
+      with the library in order to run.</para>
+    </sect3>
+
+
+    <sect3 id="lgpl-terms">
+      <title>GNU LESSER GENERAL PUBLIC LICENSE</title>
+      <subtitle>TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND
+      MODIFICATION</subtitle>
+
+      <para>0. This License Agreement applies to any software library or
+      other program which contains a notice placed by the copyright
+      holder or other authorized party saying it may be distributed
+      under the terms of this Lesser General Public License (also called
+      &ldquo;this License&rdquo;).  Each licensee is addressed as
+      &ldquo;you&rdquo;.</para>
+
+      <para>A &ldquo;library&rdquo; means a collection of software
+      functions and/or data prepared so as to be conveniently linked
+      with application programs (which use some of those functions and
+      data) to form executables.</para>
+
+      <para>The &ldquo;Library&rdquo;, below, refers to any such
+      software library or work which has been distributed under these
+      terms.  A &ldquo;work based on the Library&rdquo; means either the
+      Library or any derivative work under copyright law: that is to
+      say, a work containing the Library or a portion of it, either
+      verbatim or with modifications and/or translated straightforwardly
+      into another language.  (Hereinafter, translation is included
+      without limitation in the term &ldquo;modification&rdquo;.)</para>
+
+      <para>&ldquo;Source code&rdquo; for a work means the preferred
+      form of the work for making modifications to it.  For a library,
+      complete source code means all the source code for all modules it
+      contains, plus any associated interface definition files, plus the
+      scripts used to control compilation and installation of the
+      library.</para>
+
+      <para>Activities other than copying, distribution and modification
+      are not covered by this License; they are outside its scope.  The
+      act of running a program using the Library is not restricted, and
+      output from such a program is covered only if its contents
+      constitute a work based on the Library (independent of the use of
+      the Library in a tool for writing it).  Whether that is true
+      depends on what the Library does and what the program that uses
+      the Library does.</para>
+
+      <para>1. You may copy and distribute verbatim copies of the
+      Library&rsquo;s complete source code as you receive it, in any
+      medium, provided that you conspicuously and appropriately publish
+      on each copy an appropriate copyright notice and disclaimer of
+      warranty; keep intact all the notices that refer to this License
+      and to the absence of any warranty; and distribute a copy of this
+      License along with the Library.</para>
+
+      <para>You may charge a fee for the physical act of transferring a
+      copy, and you may at your option offer warranty protection in
+      exchange for a fee.</para>
+
+      <para>2. You may modify your copy or copies of the Library or any
+      portion of it, thus forming a work based on the Library, and copy
+      and distribute such modifications or work under the terms of
+      Section 1 above, provided that you also meet all of these
+      conditions:</para>
+
+      <blockquote>
+        <para>a) The modified work must itself be a software
+        library.</para>
+
+        <para>b) You must cause the files modified to carry prominent
+        notices stating that you changed the files and the date of any
+        change.</para>
+
+        <para>c) You must cause the whole of the work to be licensed at
+        no charge to all third parties under the terms of this
+        License.</para>
+
+        <para>d) If a facility in the modified Library refers to a
+        function or a table of data to be supplied by an application
+        program that uses the facility, other than as an argument passed
+        when the facility is invoked, then you must make a good faith
+        effort to ensure that, in the event an application does not
+        supply such function or table, the facility still operates, and
+        performs whatever part of its purpose remains meaningful.</para>
+
+        <para>(For example, a function in a library to compute square
+        roots has a purpose that is entirely well-defined independent of
+        the application.  Therefore, Subsection 2d requires that any
+        application-supplied function or table used by this function
+        must be optional: if the application does not supply it, the
+        square root function must still compute square roots.)</para>
+      </blockquote>
+
+      <para>These requirements apply to the modified work as a whole.
+      If identifiable sections of that work are not derived from the
+      Library, and can be reasonably considered independent and separate
+      works in themselves, then this License, and its terms, do not
+      apply to those sections when you distribute them as separate
+      works.  But when you distribute the same sections as part of a
+      whole which is a work based on the Library, the distribution of
+      the whole must be on the terms of this License, whose permissions
+      for other licensees extend to the entire whole, and thus to each
+      and every part regardless of who wrote it.</para>
+
+      <para>Thus, it is not the intent of this section to claim rights
+      or contest your rights to work written entirely by you; rather,
+      the intent is to exercise the right to control the distribution of
+      derivative or collective works based on the Library.</para>
+
+      <para>In addition, mere aggregation of another work not based on
+      the Library with the Library (or with a work based on the Library)
+      on a volume of a storage or distribution medium does not bring the
+      other work under the scope of this License.</para>
+
+      <para>3. You may opt to apply the terms of the ordinary GNU
+      General Public License instead of this License to a given copy of
+      the Library.  To do this, you must alter all the notices that
+      refer to this License, so that they refer to the ordinary GNU
+      General Public License, version 2, instead of to this License.
+      (If a newer version than version 2 of the ordinary GNU General
+      Public License has appeared, then you can specify that version
+      instead if you wish.)  Do not make any other change in these
+      notices.</para>
+
+      <para>Once this change is made in a given copy, it is irreversible
+      for that copy, so the ordinary GNU General Public License applies
+      to all subsequent copies and derivative works made from that
+      copy.</para>
+
+      <para>This option is useful when you wish to copy part of the code
+      of the Library into a program that is not a library.</para>
+
+      <para>4. You may copy and distribute the Library (or a portion or
+      derivative of it, under Section 2) in object code or executable
+      form under the terms of Sections 1 and 2 above provided that you
+      accompany it with the complete corresponding machine-readable
+      source code, which must be distributed under the terms of Sections
+      1 and 2 above on a medium customarily used for software
+      interchange.</para>
+
+      <para>If distribution of object code is made by offering access to
+      copy from a designated place, then offering equivalent access to
+      copy the source code from the same place satisfies the requirement
+      to distribute the source code, even though third parties are not
+      compelled to copy the source along with the object code.</para>
+
+      <para>5. A program that contains no derivative of any portion of
+      the Library, but is designed to work with the Library by being
+      compiled or linked with it, is called a &ldquo;work that uses the
+      Library&rdquo;.  Such a work, in isolation, is not a derivative
+      work of the Library, and therefore falls outside the scope of this
+      License.</para>
+
+      <para>However, linking a &ldquo;work that uses the Library&rdquo;
+      with the Library creates an executable that is a derivative of the
+      Library (because it contains portions of the Library), rather than
+      a &ldquo;work that uses the library&rdquo;.  The executable is
+      therefore covered by this License.  Section 6 states terms for
+      distribution of such executables.</para>
+
+      <para>When a &ldquo;work that uses the Library&rdquo; uses
+      material from a header file that is part of the Library, the
+      object code for the work may be a derivative work of the Library
+      even though the source code is not.  Whether this is true is
+      especially significant if the work can be linked without the
+      Library, or if the work is itself a library.  The threshold for
+      this to be true is not precisely defined by law.</para>
+
+      <para>If such an object file uses only numerical parameters, data
+      structure layouts and accessors, and small macros and small inline
+      functions (ten lines or less in length), then the use of the
+      object file is unrestricted, regardless of whether it is legally a
+      derivative work.  (Executables containing this object code plus
+      portions of the Library will still fall under Section 6.)</para>
+
+      <para>Otherwise, if the work is a derivative of the Library, you
+      may distribute the object code for the work under the terms of
+      Section 6.  Any executables containing that work also fall under
+      Section 6, whether or not they are linked directly with the
+      Library itself.</para>
+
+      <para>6. As an exception to the Sections above, you may also
+      combine or link a &ldquo;work that uses the Library&rdquo; with
+      the Library to produce a work containing portions of the Library,
+      and distribute that work under terms of your choice, provided that
+      the terms permit modification of the work for the customer&rsquo;s
+      own use and reverse engineering for debugging such
+      modifications.</para>
+
+      <para>You must give prominent notice with each copy of the work
+      that the Library is used in it and that the Library and its use
+      are covered by this License.  You must supply a copy of this
+      License.  If the work during execution displays copyright notices,
+      you must include the copyright notice for the Library among them,
+      as well as a reference directing the user to the copy of this
+      License.  Also, you must do one of these things:</para>
+
+      <blockquote>
+        <para>a) Accompany the work with the complete corresponding
+        machine-readable source code for the Library including whatever
+        changes were used in the work (which must be distributed under
+        Sections 1 and 2 above); and, if the work is an executable
+        linked with the Library, with the complete machine-readable
+        &ldquo;work that uses the Library&rdquo;, as object code and/or
+        source code, so that the user can modify the Library and then
+        relink to produce a modified executable containing the modified
+        Library.  (It is understood that the user who changes the
+        contents of definitions files in the Library will not
+        necessarily be able to recompile the application to use the
+        modified definitions.)</para>
+
+        <para>b) Use a suitable shared library mechanism for linking
+        with the Library.  A suitable mechanism is one that (1) uses at
+        run time a copy of the library already present on the
+        user&rsquo;s computer system, rather than copying library
+        functions into the executable, and (2) will operate properly
+        with a modified version of the library, if the user installs
+        one, as long as the modified version is interface-compatible
+        with the version that the work was made with.</para>
+
+        <para>c) Accompany the work with a written offer, valid for at
+        least three years, to give the same user the materials specified
+        in Subsection 6a, above, for a charge no more than the cost of
+        performing this distribution.</para>
+
+        <para>d) If distribution of the work is made by offering access
+        to copy from a designated place, offer equivalent access to copy
+        the above specified materials from the same place.</para>
+
+        <para>e) Verify that the user has already received a copy of
+        these materials or that you have already sent this user a
+        copy.</para>
+      </blockquote>
+
+      <para>For an executable, the required form of the &ldquo;work that
+      uses the Library&rdquo; must include any data and utility programs
+      needed for reproducing the executable from it.  However, as a
+      special exception, the materials to be distributed need not
+      include anything that is normally distributed (in either source or
+      binary form) with the major components (compiler, kernel, and so
+      on) of the operating system on which the executable runs, unless
+      that component itself accompanies the executable.</para>
+
+      <para>It may happen that this requirement contradicts the license
+      restrictions of other proprietary libraries that do not normally
+      accompany the operating system.  Such a contradiction means you
+      cannot use both them and the Library together in an executable
+      that you distribute.</para>
+
+      <para>7. You may place library facilities that are a work based on
+      the Library side-by-side in a single library together with other
+      library facilities not covered by this License, and distribute
+      such a combined library, provided that the separate distribution
+      of the work based on the Library and of the other library
+      facilities is otherwise permitted, and provided that you do these
+      two things:</para>
+
+      <blockquote>
+        <para>a) Accompany the combined library with a copy of the same
+        work based on the Library, uncombined with any other library
+        facilities.  This must be distributed under the terms of the
+        Sections above.</para>
+
+        <para>b) Give prominent notice with the combined library of the
+        fact that part of it is a work based on the Library, and
+        explaining where to find the accompanying uncombined form of the
+        same work.</para>
+      </blockquote>
+
+      <para>8. You may not copy, modify, sublicense, link with, or
+      distribute the Library except as expressly provided under this
+      License.  Any attempt otherwise to copy, modify, sublicense, link
+      with, or distribute the Library is void, and will automatically
+      terminate your rights under this License.  However, parties who
+      have received copies, or rights, from you under this License will
+      not have their licenses terminated so long as such parties remain
+      in full compliance.</para>
+
+      <para>9. You are not required to accept this License, since you
+      have not signed it.  However, nothing else grants you permission
+      to modify or distribute the Library or its derivative works.
+      These actions are prohibited by law if you do not accept this
+      License.  Therefore, by modifying or distributing the Library (or
+      any work based on the Library), you indicate your acceptance of
+      this License to do so, and all its terms and conditions for
+      copying, distributing or modifying the Library or works based on
+      it.</para>
+
+      <para>10. Each time you redistribute the Library (or any work
+      based on the Library), the recipient automatically receives a
+      license from the original licensor to copy, distribute, link with
+      or modify the Library subject to these terms and conditions.  You
+      may not impose any further restrictions on the recipients&rsquo;
+      exercise of the rights granted herein.  You are not responsible
+      for enforcing compliance by third parties with this
+      License.</para>
+
+      <para>11. If, as a consequence of a court judgment or allegation
+      of patent infringement or for any other reason (not limited to
+      patent issues), conditions are imposed on you (whether by court
+      order, agreement or otherwise) that contradict the conditions of
+      this License, they do not excuse you from the conditions of this
+      License.  If you cannot distribute so as to satisfy simultaneously
+      your obligations under this License and any other pertinent
+      obligations, then as a consequence you may not distribute the
+      Library at all.  For example, if a patent license would not permit
+      royalty-free redistribution of the Library by all those who
+      receive copies directly or indirectly through you, then the only
+      way you could satisfy both it and this License would be to refrain
+      entirely from distribution of the Library.</para>
+
+      <para>If any portion of this section is held invalid or
+      unenforceable under any particular circumstance, the balance of
+      the section is intended to apply, and the section as a whole is
+      intended to apply in other circumstances.</para>
+
+      <para>It is not the purpose of this section to induce you to
+      infringe any patents or other property right claims or to contest
+      validity of any such claims; this section has the sole purpose of
+      protecting the integrity of the free software distribution system
+      which is implemented by public license practices.  Many people
+      have made generous contributions to the wide range of software
+      distributed through that system in reliance on consistent
+      application of that system; it is up to the author/donor to decide
+      if he or she is willing to distribute software through any other
+      system and a licensee cannot impose that choice.</para>
+
+      <para>This section is intended to make thoroughly clear what is
+      believed to be a consequence of the rest of this License.</para>
+
+      <para>12. If the distribution and/or use of the Library is
+      restricted in certain countries either by patents or by
+      copyrighted interfaces, the original copyright holder who places
+      the Library under this License may add an explicit geographical
+      distribution limitation excluding those countries, so that
+      distribution is permitted only in or among countries not thus
+      excluded.  In such case, this License incorporates the limitation
+      as if written in the body of this License.</para>
+
+      <para>13. The Free Software Foundation may publish revised and/or
+      new versions of the Lesser General Public License from time to
+      time.  Such new versions will be similar in spirit to the present
+      version, but may differ in detail to address new problems or
+      concerns.</para>
+
+      <para>Each version is given a distinguishing version number.  If
+      the Library specifies a version number of this License which
+      applies to it and &ldquo;any later version&rdquo;, you have the
+      option of following the terms and conditions either of that
+      version or of any later version published by the Free Software
+      Foundation.  If the Library does not specify a license version
+      number, you may choose any version ever published by the Free
+      Software Foundation.</para>
+
+      <para>14. If you wish to incorporate parts of the Library into
+      other free programs whose distribution conditions are incompatible
+      with these, write to the author to ask for permission.  For
+      software which is copyrighted by the Free Software Foundation,
+      write to the Free Software Foundation; we sometimes make
+      exceptions for this.  Our decision will be guided by the two goals
+      of preserving the free status of all derivatives of our free
+      software and of promoting the sharing and reuse of software
+      generally.</para>
+
+      <para>NO WARRANTY</para>
+
+      <para>15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS
+      NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE
+      LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+      HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY &ldquo;AS
+      IS&rdquo; WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR
+      IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+      MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE
+      RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU.
+      SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
+      NECESSARY SERVICING, REPAIR OR CORRECTION.</para>
+
+      <para>16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED
+      TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO
+      MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE
+      LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
+      INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
+      INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF
+      DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
+      OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY
+      OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
+      ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</para>
+
+      <para>END OF TERMS AND CONDITIONS</para>
+    </sect3>
+
+
+    <sect3 id="lgpl-howto">
+      <title>How to Apply These Terms to Your New Libraries</title>
+
+      <para>If you develop a new library, and you want it to be of the
+      greatest possible use to the public, we recommend making it free
+      software that everyone can redistribute and change.  You can do so
+      by permitting redistribution under these terms (or, alternatively,
+      under the terms of the ordinary General Public License).</para>
+
+      <para>To apply these terms, attach the following notices to the
+      library.  It is safest to attach them to the start of each source
+      file to most effectively convey the exclusion of warranty; and
+      each file should have at least the &ldquo;copyright&rdquo; line
+      and a pointer to where the full notice is found.</para>
+
+      <blockquote>
+        <para>&lt;one line to give the library&rsquo;s name and a brief
+        idea of what it does.&gt;</para>
+
+        <para>Copyright &copy; &lt;year&gt; &lt;name of
+        author&gt;</para>
+
+        <para>This library is free software; you can redistribute it
+        and/or modify it under the terms of the GNU Lesser General
+        Public License as published by the Free Software Foundation;
+        either version 2.1 of the License, or (at your option) any later
+        version.</para>
+
+        <para>This library is distributed in the hope that it will be
+        useful, but WITHOUT ANY WARRANTY; without even the implied
+        warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+        See the GNU Lesser General Public License for more
+        details.</para>
+
+        <para>You should have received a copy of the GNU Lesser General
+        Public License along with this library; if not, write to the
+        Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+        Boston, MA 02111-1307 USA</para>
+      </blockquote>
+
+      <para>Also add information on how to contact you by electronic and
+      paper mail.</para>
+
+      <para>You should also get your employer (if you work as a
+      programmer) or your school, if any, to sign a &ldquo;copyright
+      disclaimer&rdquo; for the library, if necessary.  Here is a
+      sample; alter the names:</para>
+
+      <blockquote>
+        <para>Yoyodyne, Inc., hereby disclaims all copyright interest in
+        the library `Frob' (a library for tweaking knobs) written by
+        James Random Hacker.</para>
+
+        <para>&lt;signature of Ty Coon&gt;, 1 April 1990</para>
+
+        <para>Ty Coon, President of Vice</para>
+      </blockquote>
+
+      <para>That&rsquo;s all there is to it!</para>
+    </sect3>
+  </sect2>
+
+
+  <?hard-pagebreak?>
+  <sect2 id="userman-license">
+    <title>MySQL++ User Manual License</title>
+
+    <sect3 id="userman-license-copyright">
+      <title>I. COPYRIGHT</title>
+
+      <para>The copyright to the MySQL++ User Manual is owned by its
+      authors.</para>
+    </sect3>
+
+    <sect3 id="userman-license-main">
+      <title>II. LICENSE</title>
+
+      <para>The MySQL++ User Manual may be reproduced and distributed in
+      whole or in part, in any medium physical or electronic, provided
+      that this license notice is displayed in the reproduction.
+      Commercial redistribution is permitted and encouraged. Thirty days
+      advance notice via email to the authors of redistribution is
+      appreciated, to give the authors time to provide updated
+      documents.</para>
+
+      <sect4 id="userman-license-req">
+        <title>A. REQUIREMENTS OF MODIFIED WORKS</title>
+
+        <para>All modified documents, including translations,
+        anthologies, and partial documents, must meet the following
+        requirements:</para>
+
+        <orderedlist numeration="arabic">
+          <listitem><para>The modified version must be labeled as
+          such.</para></listitem>
+
+          <listitem><para>The person making the modifications must be
+          identified.</para></listitem>
+
+          <listitem><para>Acknowledgement of the original author must be
+          retained.</para></listitem>
+
+          <listitem><para>The location of the original unmodified
+          document be identified.</para></listitem>
+
+          <listitem><para>The original authors&rsquo; names may not be
+          used to assert or imply endorsement of the resulting document
+          without the original authors&rsquo;
+          permission.</para></listitem>
+        </orderedlist>
+
+        <para>In addition it is requested that:</para>
+
+        <orderedlist numeration="arabic">
+          <listitem><para>The modifications (including deletions) be
+          noted.</para></listitem>
+
+          <listitem><para>The authors be notified by email of the
+          modification in advance of redistribution, if an email address
+          is provided in the document.</para></listitem>
+        </orderedlist>
+
+        <para>Mere aggregation of the MySQL++ User Manual with other
+        documents or programs on the same media shall not cause this
+        license to apply to those other works.</para>
+
+        <para>All translations, derivative documents, or modified
+        documents that incorporate the MySQL++ User Manual may not have
+        more restrictive license terms than these, except that you may
+        require distributors to make the resulting document available in
+        source format.</para>
+      </sect4>
+    </sect3>
+  </sect2>
+</sect1>

ADDED   doc/userman/mktxt
Index: doc/userman/mktxt
==================================================================
--- /dev/null
+++ doc/userman/mktxt
@@ -0,0 +1,19 @@
+#!/bin/sh
+# Script to convert C++ source files to a text format, with 4 spaces for
+# every tab, and with the leading block comment removed.  Used to
+# reformat the example programs so they can be xincluded directly into
+# the DocBook during XSLT processing.
+
+TXTFILE=$1
+SRCFILE=`echo ../../examples/$TXTFILE | sed -e s/\\\\.txt/.cpp/`
+if [ ! -e $SRCFILE ]
+then
+	SRCFILE=`echo ../../examples/$TXTFILE | sed -e s/\\\\.txt/.h/`
+fi
+CLINE=`grep -n '\*\*/' $SRCFILE |cut -f1 -d:`
+LINE=`echo $CLINE + 2 |bc`
+
+#echo Converting $SRCFILE to $TXTFILE, starting at line $LINE...
+
+expand -t4 $SRCFILE | tail -n +$LINE > $TXTFILE
+

ADDED   doc/userman/overview.dbx
Index: doc/userman/overview.dbx
==================================================================
--- /dev/null
+++ doc/userman/overview.dbx
@@ -0,0 +1,211 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="overview">
+  <title>Overview</title>
+
+  <para>MySQL++ has a lot of complexity and power to cope with the
+  variety of ways people use databases, but at bottom it doesn&rsquo;t
+  work all that differently than other database access APIs. The usage
+  pattern looks like this:</para>
+
+  <orderedlist>
+    <listitem><para>Open the connection</para></listitem>
+
+    <listitem><para>Form and execute the query</para></listitem>
+
+    <listitem><para>If successful, iterate through the result
+    set</para></listitem>
+
+    <listitem><para>Else, deal with errors</para></listitem>
+  </orderedlist>
+
+  <para>Each of these steps corresponds to a MySQL++ class or class
+  hierarchy. An overview of each follows.</para>
+
+
+  <sect2 id="Connection">
+    <title>The Connection Object</title>
+
+    <para>A <ulink type="classref" url="Connection"/> object manages the
+    connection to the MySQL server. You need at least one of these
+    objects to do anything. Because the other MySQL++ objects your
+    program will use often depend (at least indirectly) on the
+    <classname>Connection</classname> instance, the
+    <classname>Connection</classname> object needs to live at least as
+    long as all other MySQL++ objects in your program.</para>
+
+    <para>MySQL supports many different types of data connection between
+    the client and the server: TCP/IP, Unix domain sockets, and Windows
+    named pipes. The generic <classname>Connection</classname> class
+    supports all of these, figuring out which one you mean based on the
+    parameters you pass to
+    <methodname>Connection::connect()</methodname>. But if you know in
+    advance that your program only needs one particular connection type,
+    there are subclasses with simpler interfaces. For example,
+    there&rsquo;s <ulink type="classref" url="TCPConnection"/> if you
+    know your program will always use a networked database
+    server.</para>
+  </sect2>
+
+
+  <sect2 id="Query">
+    <title>The Query Object</title>
+
+    <para>Most often, you create SQL queries using a <ulink
+    type="classref" url="Query"/> object created by the
+    <classname>Connection</classname> object.</para>
+
+    <para><classname>Query</classname> acts as a standard C++ output
+    stream, so you can write data to it like you would to
+    <classname>std::cout</classname> or
+    <classname>std::ostringstream</classname>. This is the most C++ish
+    way MySQL++ provides for building up a query string.  The library
+    includes <ulink url="../refman/manip_8h.html">stream
+    manipulators</ulink> that are type-aware so it&rsquo;s easy to build
+    up syntactically-correct SQL.</para>
+
+    <para><classname>Query</classname> also has a feature called <xref
+    linkend="tquery"/> which work something like C&rsquo;s
+    <function>printf()</function> function: you set up a fixed query
+    string with tags inside that indicate where to insert the variable
+    parts. If you have multiple queries that are structurally similar,
+    you simply set up one template query, and use that in the various
+    locations of your program.</para>
+
+    <para>A third method for building queries is to use
+    <classname>Query</classname> with <xref linkend="ssqlsintro"/>
+    (SSQLS). This feature lets you create C++ structures that mirror
+    your database schemas. These in turn give
+    <classname>Query</classname> the information it needs to build many
+    common SQL queries for you. It can <command>INSERT</command>,
+    <command>REPLACE</command> and <command>UPDATE</command> rows in a
+    table given the data in SSQLS form. It can also generate
+    <command>SELECT * FROM SomeTable</command> queries and store the
+    results as an STL collection of SSQLSes.</para>
+  </sect2>
+
+
+  <sect2 id="Result">
+    <title>Result Sets</title>
+
+    <para>The field data in a result set are stored in a special
+    <classname>std::string</classname>-like class called <ulink
+    type="classref" url="String"/>. This class has conversion operators
+    that let you automatically convert these objects to any of the basic
+    C data types. Additionally, MySQL++ defines classes like <ulink
+    type="structref" url="DateTime"/>, which you can initialize from a
+    MySQL <command>DATETIME</command> string. These automatic
+    conversions are protected against bad conversions, and can either
+    set a warning flag or throw an exception, depending on how you set
+    the library up.</para>
+
+    <para>As for the result sets as a whole, MySQL++ has a number of
+    different ways of representing them:</para>
+
+    <sect3 id="SimpleResult">
+      <title>Queries That Do Not Return Data</title>
+
+      <para>Not all SQL queries return data. An example is
+      <command>CREATE TABLE</command>. For these types of queries, there
+      is a special result type (<ulink type="classref"
+      url="SimpleResult"/>) that simply reports the state resulting from
+      the query: whether the query was successful, how many rows it
+      impacted (if any), etc.</para>
+    </sect3>
+
+    <sect3 id="StoreQueryResult">
+      <title>Queries That Return Data: MySQL++ Data Structures</title>
+
+      <para>The most direct way to retrieve a result set is to use
+      <methodname>Query::store()</methodname>. This returns a <ulink
+      type="classref" url="StoreQueryResult"/> object, which derives
+      from <classname>std::vector&lt;mysqlpp::Row&gt;</classname>,
+      making it a random-access container of <ulink type="classref"
+      url="Row"/>s. In turn, each <classname>Row</classname> object is
+      like a <classname>std::vector</classname> of
+      <classname>String</classname> objects, one for each field in the
+      result set. Therefore, you can treat
+      <classname>StoreQueryResult</classname> as a two-dimensional
+      array: you can get the 5th field on the 2nd row by simply saying
+      <methodname>result[1][4]</methodname>. You can also access row
+      elements by field name, like this:
+      <methodname>result[2]["price"]</methodname>.</para>
+
+      <para>A less direct way of working with query results is to use
+      <methodname>Query::use()</methodname>, which returns a <ulink
+      type="classref" url="UseQueryResult"/> object. This class acts
+      like an STL input iterator rather than a
+      <classname>std::vector</classname>: you walk through your result
+      set processing one row at a time, always going forward. You
+      can&rsquo;t seek around in the result set, and you can&rsquo;t
+      know how many results are in the set until you find the end. In
+      payment for that inconvenience, you get better memory efficiency,
+      because the entire result set doesn&rsquo;t need to be stored in
+      RAM. This is very useful when you need large result sets.</para>
+    </sect3>
+
+    <sect3 id="storein">
+      <title>Queries That Return Data: Specialized SQL
+      Structures</title>
+
+      <para>Accessing results through MySQL++&rsquo;s data structures is
+      a pretty low level of abstraction. It&rsquo;s better than using
+      the MySQL C API, but not by much. You can elevate things a little
+      closer to the level of the problem space by using the <xref
+      linkend="ssqlsintro"/> (SSQLS) feature. This lets you define C++
+      structures that match the table structures in your database
+      schema. In addition, it&rsquo;s easy to use SSQLSes with regular
+      STL containers (and thus, algorithms) so you don&rsquo;t have to
+      deal with the quirks of MySQL++&rsquo;s data structures.</para>
+
+      <para>The advantage of this method is that your program will
+      require very little embedded SQL code. You can simply execute a
+      query, and receive your results as C++ data structures, which can
+      be accessed just as you would any other structure. The results can
+      be accessed through the Row object, or you can ask the library to
+      dump the results into an STL container &mdash; sequential or
+      set-associative, it doesn&rsquo;t matter &mdash; for you. Consider
+      this:</para>
+
+      <programlisting>
+vector&lt;stock&gt; v;
+query &lt;&lt; "SELECT * FROM stock";
+query.storein(v);
+for (vector&lt;stock&gt;::iterator it = v.begin(); it != v.end(); ++it) {
+  cout &lt;&lt; "Price: " &lt;&lt; it-&gt;price &lt;&lt; endl;
+}</programlisting>
+
+      <para>Isn&rsquo;t that slick?</para>
+
+      <para>If you don&rsquo;t want to create SSQLSes to match your
+      table structures, as of MySQL++ v3 you can now use
+      <classname>Row</classname> here instead:</para>
+
+      <programlisting>
+vector&lt;mysqlpp::Row&gt; v;
+query &lt;&lt; "SELECT * FROM stock";
+query.storein(v);
+for (vector&lt;mysqlpp::Row&gt;::iterator it = v.begin(); it != v.end(); ++it) {
+  cout &lt;&lt; "Price: " &lt;&lt; it->at("price") &lt;&lt; endl;
+}</programlisting>
+
+      <para>It lacks a certain syntactic elegance, but it has its
+      uses.</para>
+    </sect3>
+  </sect2>
+
+
+  <sect2 id="exceptions-intro">
+    <title>Exceptions</title>
+
+    <para>By default, the library throws <xref linkend="exceptions"/>
+    whenever it encounters an error. You can ask the library to set
+    an error flag instead, if you like, but the exceptions carry more
+    information. Not only do they include a string member telling you
+    why the exception was thrown, there are several exception types,
+    so you can distinguish between different error types within a
+    single <symbol>try</symbol> block.</para>
+  </sect2>
+</sect1>

ADDED   doc/userman/section-template.dbx
Index: doc/userman/section-template.dbx
==================================================================
--- /dev/null
+++ doc/userman/section-template.dbx
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="SOMETHING_UNIQUE">
+  <title>SECTION TITLE</title>
+
+  <para>FIRST PARAGRAPH</para>
+</sect1>

ADDED   doc/userman/ssqls.dbx
Index: doc/userman/ssqls.dbx
==================================================================
--- /dev/null
+++ doc/userman/ssqls.dbx
@@ -0,0 +1,635 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="ssqls">
+  <title>Specialized SQL Structures</title>
+
+  <para>The Specialized SQL Structure (SSQLS) feature lets you easily
+  define C++ structures that match the form of your SQL tables. Because
+  of the extra functionality that this feature builds into these
+  structures, MySQL++ can populate them automatically when retrieving
+  data from the database; with queries returning many records, you can
+  ask MySQL++ to populate an STL container of your SSQLS records with
+  the results. When updating the database, MySQL++ can use SSQLS
+  structures to match existing data, and it can insert SSQLS structures
+  directly into the database.</para>
+
+  <para>You define an SSQLS using one of several macros defined in
+  <filename>ssqls.h</filename>. The following sections will discuss each
+  macro type separately, beginning with the easiest and most generally
+  useful.</para>
+
+
+  <sect2 id="sql_create">
+    <title>sql_create</title>
+
+    <para>This is the most basic sort of SSQLS declaration:</para>
+
+    <programlisting>
+sql_create_6(stock, 1, 6,
+    mysqlpp::sql_char, item,
+    mysqlpp::sql_bigint, num,
+    mysqlpp::sql_double, weight,
+    mysqlpp::sql_decimal, price,
+    mysqlpp::sql_date, sdate,
+    mysqlpp::Null&lt;mysqlpp::sql_mediumtext&gt;, description)</programlisting>
+
+    <para>This creates a C++ structure called
+    <classname>stock</classname> containing six member
+    variables (<varname>item</varname>, <varname>num</varname>,
+    <varname>weight</varname>, <varname>price</varname>,
+    <varname>sdate</varname>, and <varname>description</varname>),
+    along with some constructors and other useful member
+    functions.</para>
+
+    <para>The parameter before each field name is the C++ data type
+    that will be used to hold that value in the SSQLS. MySQL++ has
+    a <type>sql_*</type> typedef for almost every data type MySQL
+    understands.<footnote><para>MySQL++ doesn&rsquo;t have typedefs
+    for some of the more exotic data types, like those for the
+    geospatial types. Patches to correct this will be thoughtfully
+    considered.</para></footnote> While it&rsquo;s possible to use
+    some regular C and C++ data types here, it&rsquo;s safer to use
+    the ones MySQL++ defines, as they&rsquo;re likely to be a better
+    match to the types used by the database server. Plus, if you use
+    the predefined types, you are assured that MySQL++ knows how to
+    do the data conversions between the C++ and SQL type systems. If
+    you use other data types and the C++ compiler can&rsquo;t convert
+    it to one MySQL++ already understands, MySQL++ will throw a
+    <ulink type="classref" url="TypeLookupFailed"/> exception. The
+    <type>sql_*</type> types are defined in MySQL++&rsquo;s
+    <filename>sql_types.h</filename> header. The naming scheme is
+    easy to learn when you know the SQL data type names.</para>
+
+    <para>Another thing you&rsquo;ll notice above is the type of the
+    last column. We&rsquo;ve wrapped it in MySQL++&rsquo;s <ulink
+    type="classref" url="Null"/> template, which enables it to take a
+    SQL null value in addition to the values the base data type allows.
+    For more on this topic, see <xref linkend="sql-null"/>.</para>
+
+    <para>One of the generated constructors takes a reference to
+    a <ulink type="classref" url="Row"/>, allowing you to easily
+    populate a vector of stocks like so:</para>
+
+    <programlisting>
+vector&lt;stock&gt; result; 
+query.storein(result);</programlisting>
+
+    <para>MySQL++ takes care of mapping result set data to SSQLS
+    fields. The SSQLS doesn&rsquo;t have to have the same number
+    of fields as the result set, and the order of fields in the
+    result set doesn&rsquo;t have to match the order of fields in
+    the SSQLS. Fields in the result set that don&rsquo;t exist in the
+    SSQLS are just quietly dropped, and fields in the SSQLS for which
+    there is no data in the result get set to a default value.</para>
+
+    <para>The general format of this set of macros is:</para>
+
+    <programlisting>
+sql_create_#(NAME, COMPCOUNT, SETCOUNT, TYPE1, ITEM1, ... TYPE#, ITEM#)</programlisting>
+
+    <para>Where # is the number of member variables,
+    <parameter>NAME</parameter> is the name of the structure you wish to
+    create, <parameter>TYPEx</parameter> is the type of a member
+    variable, and <parameter>ITEMx</parameter> is that variable&rsquo;s
+    name.</para>
+
+    <para>The <parameter>COMPCOUNT</parameter> and
+    <parameter>SETCOUNT</parameter> arguments are described in the
+    next section.</para>
+  </sect2>
+
+
+  <sect2 id="ssqls-compare-init">
+    <title>SSQLS Comparison and Initialization</title>
+
+    <para><varname>sql_create_</varname><emphasis>x</emphasis> adds
+    member functions and operators to each SSQLS that allow you to
+    compare one SSQLS instance to another. These functions compare the
+    first <parameter>COMPCOUNT</parameter> fields in the structure. In
+    the example above, <parameter>COMPCOUNT</parameter> is 1, so only
+    the <varname>item</varname> field will be checked when comparing two
+    <classname>stock</classname> structures.</para>
+
+    <para>This feature works best when your table&rsquo;s
+    &ldquo;key&rdquo; fields are the first ones in the SSQLS and
+    you set <parameter>COMPCOUNT</parameter> equal to the number
+    of key fields. That way, a check for equality between two SSQLS
+    structures in your C++ code will give the same results as a check
+    for equality in SQL.</para>
+
+    <para><parameter>COMPCOUNT</parameter> must
+    be at least 1. The current implementation of
+    <varname>sql_create_</varname><emphasis>x</emphasis> cannot create
+    an SSQLS without comparison member functions.</para>
+
+    <para>Because our <classname>stock</classname> structure
+    is less-than-comparable, you can use it in STL algorithms
+    and containers that require this, such as STL&rsquo;s associative
+    containers:</para>
+
+    <programlisting>
+std::set&lt;stock&gt; result;   
+query.storein(result);
+cout &lt;&lt; result.lower_bound(stock("Hamburger"))-&gt;item &lt;&lt; endl;</programlisting>
+
+    <para>This will print the first item in the result set that begins
+    with &ldquo;Hamburger.&rdquo;</para>
+
+    <para>The third parameter to
+    <varname>sql_create_</varname><emphasis>x</emphasis> is
+    <parameter>SETCOUNT</parameter>. If this is nonzero, it adds
+    an initialization constructor and a <function>set()</function>
+    member function taking the given number of arguments, for setting
+    the first <emphasis>N</emphasis> fields of the structure. For
+    example, you could change the above example like so:</para>
+
+    <programlisting>
+sql_create_5(stock, 1, 2,
+    mysqlpp::sql_char, item,
+    mysqlpp::sql_bigint, num,         
+    mysqlpp::sql_double, weight,  
+    mysqlpp::sql_decimal, price,  
+    mysqlpp::sql_date, sdate)
+    
+stock foo("Hotdog", 52);</programlisting>
+
+    <para>In addition to this 2-parameter constructor, this version
+    of the <classname>stock</classname> SSQLS will have a similar
+    2-parameter <function>set()</function> member function.</para>
+
+    <para>The <parameter>COMPCOUNT</parameter> and
+    <parameter>SETCOUNT</parameter> values cannot be equal. If they
+    are, the macro will generate two initialization constructors with
+    identical parameter lists, which is illegal in C++. You might be
+    asking, why does there need to be a constructor for comparison to
+    begin with? It&rsquo;s often convenient to be able to say something
+    like <userinput>x == stock("Hotdog")</userinput>. This requires
+    that there be a constructor taking <parameter>COMPCOUNT</parameter>
+    arguments to create the temporary <classname>stock</classname>
+    instance used in the comparison.</para>
+
+    <para>This limitation is not a problem in practice. If you
+    want the same number of parameters in the initialization
+    constructor as the number of fields used in comparisons,
+    pass 0 for <parameter>SETCOUNT</parameter>. This suppresses
+    the duplicate constructor you&rsquo;d get if you used the
+    <parameter>COMPCOUNT</parameter> value instead. This is most
+    useful in very small SSQLSes, since it&rsquo;s easier for the
+    number of key fields to equal the number of fields you want to
+    compare on:</para>
+
+    <programlisting>
+sql_create_1(stock_item, 1, 0, mysqlpp::sql_char, item)</programlisting>
+  </sect2>
+
+
+  <sect2 id="ssqls-extra-features">
+    <title>Additional Features of Specialized SQL
+    Structures</title>
+
+    <para>Up to this point, we haven&rsquo;t been using all of the
+    features in the SSQLS structures we&rsquo;ve been generating.  What
+    else can we do with SSQLSes? Consider this:</para>
+
+    <programlisting>
+query.insert(s);</programlisting>
+
+    <para>This does exactly what you think it does: it builds
+    an <command>INSERT</command> query to insert the contents
+    of <varname>s</varname> into the database. You have only to
+    call <methodname>query::execute()</methodname> to actually
+    insert it. This is possible because SSQLSes have functions that
+    <classname>Query</classname> can call to get the list of fields
+    and such, which it uses to build the <command>INSERT</command>
+    query. <methodname>query::update()</methodname> and
+    <methodname>query::replace()</methodname> also rely on these
+    features.</para>
+
+    <para>Another feature you might find a use for is changing the
+    table name MySQL++ uses to build queries involving SSQLSes. By
+    default, the database server table is assumed to have the same name
+    as the SSQLS structure type. But if this is inconvenient, you can
+    globally change the table name used in queries like this:</para>
+
+    <programlisting>
+stock::table("MyStockData");</programlisting>
+
+    <para>It&rsquo;s also possible to change the name of a table on
+    a per-instance basis:</para>
+
+    <programlisting>
+stock s;
+s.instance_table("AlternateTable");</programlisting>
+
+    <para>This is useful when you have an SSQLS definition that is
+    compatible with multiple tables, so the table name to use for each
+    instance is different. The simplest way this can happen is if the
+    tables all have identical definitions; it saves you from having
+    to define a separate SSQLS for each table. It is also useful for
+    mapping a class hierarchy onto a set of table definitions. The
+    common SSQLS definition is the &ldquo;superclass&rdquo; for a
+    given set of tables.</para>
+
+    <para>Strictly speaking, you only need to use this feature in
+    multithreaded programs. Changing the static table name before
+    using each instance is safe if all changes happen within a single
+    thread. That said, it may still be convenient to change the name of
+    the table for an SSQLS instance in a single-threaded program if it
+    gets used for many operations over an extended span of code.</para>
+  </sect2>
+
+
+  <sect2 id="ssqls-in-header">
+    <title>Using an SSQLS in Multiple Modules</title>
+
+    <para>It&rsquo;s convenient to define an SSQLS in a header file so
+    you can use it in multiple modules. You run into a bit of a
+    problem, though, because each SSQLS includes a few static data
+    members to hold information common to all structures of that
+    type. (The table name and the list of field names.) When you
+    <command>#include</command> that header in more than one module,
+    you get a multiply-defined symbol error at link time.</para>
+
+    <para>The way around this is to define the preprocessor macro
+    <varname>MYSQLPP_SSQLS_NO_STATICS</varname> in <emphasis>all but
+    one</emphasis> of the modules that use the header definining the
+    SSQLS. When this macro is defined, it suppresses the static data
+    members in any SSQLS defined thereafter.</para>
+
+    <para>Imagine we have a file <filename>my_ssqls.h</filename> which
+    includes a <function>sql_create_N</function> macro call to define an
+    SSQLS, and that that SSQLS is used in at least two modules. One
+    we&rsquo;ll call <filename>foo.cpp</filename>, and we&rsquo;ll say
+    it&rsquo;s just a user of the SSQLS; it doesn&rsquo;t
+    &ldquo;own&rdquo; it. Another of the modules,
+    <filename>my_ssqls.cpp</filename> uses the SSQLS more heavily, so
+    we&rsquo;ve called it the owner of the SSQLS. If there aren&rsquo;t
+    very many modules, this works nicely:</para>
+
+    <programlisting>
+// File foo.cpp, which just uses the SSQLS, but doesn't "own" it:
+#define MYSQLPP_SSQLS_NO_STATICS
+#include "my_ssqls.h"</programlisting>
+
+    <programlisting>
+// File my_ssqls.cpp, which owns the SSQLS, so we just #include it directly
+#include "my_ssqls.h"</programlisting>
+    
+    <para>If there are many modules that need the SSQLS, adding all
+    those <command>#defines</command> can be a pain. In that case,
+    it&rsquo;s easier if you flip the above pattern on its head:</para>
+
+    <programlisting>
+// File my_ssqls.h:
+#if !defined(EXPAND_MY_SSQLS_STATICS)
+#   define MYSQLPP_SSQLS_NO_STATICS
+#endif
+sql_create_X(Y, Z....) // the SSQLS definition</programlisting>
+
+    <programlisting>
+// File foo.cpp, a mere user of the SSQLS:
+#include "my_ssqls.h"</programlisting>
+
+    <programlisting>
+// File my_ssqls.cpp, which owns the SSQLS:
+#define EXPAND_MY_SSQLS_STATICS
+#include "my_ssqls.h"</programlisting>
+  </sect2>
+
+
+  <sect2 id="ssqls-internals">
+    <title>Harnessing SSQLS Internals</title>
+
+    <para>The <symbol>sql_create</symbol> macros define several methods
+    for each SSQLS. These methods are mostly for use within the library,
+    but some of them are useful enough that you might want to harness
+    them for your own ends. Here is some pseudocode showing how the most
+    useful of these methods would be defined for the
+    <structname>stock</structname> structure used in all the
+    <filename>ssqls*.cpp</filename> examples:</para>
+
+    <programlisting>
+// Basic form
+template &lt;class Manip&gt;   
+stock_value_list&lt;Manip&gt; value_list(cchar *d = &#34;,&#34;,
+  Manip m = mysqlpp::quote) const;  
+
+template &lt;class Manip&gt;   
+stock_field_list&lt;Manip&gt; field_list(cchar *d = &#34;,&#34;,   
+  Manip m = mysqlpp::do_nothing) const;  
+
+template &lt;class Manip&gt;   
+stock_equal_list&lt;Manip&gt; equal_list(cchar *d = &#34;,&#34;,
+  cchar *e = &#34; = &#34;, Manip m = mysqlpp::quote) const;  
+
+
+// Boolean argument form
+template &lt;class Manip&gt;
+stock_cus_value_list&lt;Manip&gt; value_list([cchar *d, [Manip m,] ]   
+  bool i1, bool i2 = false, ... , bool i5 = false) const;  
+
+// List form  
+template &lt;class Manip&gt;
+stock_cus_value_list&lt;Manip&gt; value_list([cchar *d, [Manip m,] ]  
+  stock_enum i1, stock_enum i2 = stock_NULL, ...,
+  stock_enum i5 = stock_NULL) const;  
+
+// Vector form  
+template &lt;class Manip&gt;
+stock_cus_value_list&lt;Manip&gt; value_list([cchar *d, [Manip m,] ]  
+  vector&lt;bool&gt; *i) const;  
+
+...Plus the obvious equivalents for field_list() and equal_list()</programlisting>
+
+    <para>Rather than try to learn what all of these methods do at
+    once, let&rsquo;s ease into the subject. Consider this code:</para>
+
+    <programlisting>
+stock s("Dinner Rolls", 75, 0.95, 0.97, sql_date("1998-05-25"));   
+cout &lt;&lt; "Value list: " &lt;&lt; s.value_list() &lt;&lt; endl;  
+cout &lt;&lt; "Field list: " &lt;&lt; s.field_list() &lt;&lt; endl;  
+cout &lt;&lt; "Equal list: " &lt;&lt; s.equal_list() &lt;&lt; endl;</programlisting>
+
+    <para>That would produce something like:</para>
+
+    <programlisting>
+Value list: 'Dinner Rolls',75,0.95,0.97,'1998-05-25'   
+Field list: item,num,weight,price,sdate  
+Equal list: item = 'Dinner Rolls',num = 75,weight = 0.95, price = 0.97,sdate = '1998-05-25'</programlisting>
+
+    <para>That is, a &ldquo;value list&rdquo; is a list of data member
+    values within a particular SSQLS instance, a &ldquo;field
+    list&rdquo; is a list of the fields (columns) within that SSQLS, and
+    an &ldquo;equal list&rdquo; is a list in the form of an SQL equals
+    clause.</para>
+
+    <para>Just knowing that much, it shouldn&rsquo;t surprise you to
+    learn that <methodname>Query::insert()</methodname> is implemented
+    more or less like this:</para>
+
+    <programlisting>
+*this &lt;&lt; "INSERT INTO " &lt;&lt; v.table() &lt;&lt; " (" &lt;&lt; v.field_list() &lt;&lt;
+    ") VALUES (" &lt;&lt; v.value_list() &lt;&lt; ")";</programlisting>
+
+    <para>where &lsquo;v&rsquo; is the SSQLS you&rsquo;re asking the
+    Query object to insert into the database.</para>
+
+    <para>Now let&rsquo;s look at a complete example, which uses one of
+    the more complicated forms of <methodname>equal_list()</methodname>.
+    This example builds a query with fewer hard-coded strings than the
+    most obvious technique requires, which makes it more robust in the
+    face of change. Here is
+    <filename>examples/ssqls5.cpp</filename>:</para>
+
+    <programlisting><xi:include href="ssqls5.txt" parse="text" 
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>This example uses the list form of
+    <methodname>equal_list()</methodname>. The arguments
+    <varname>stock_weight</varname> and <varname>stock_price</varname>
+    are enum values equal to the position of these columns within the
+    <structname>stock</structname> table.
+    <symbol>sql_create_</symbol><emphasis>x</emphasis> generates this
+    enum for you automatically.</para>
+
+    <para>The boolean argument form of that
+    <methodname>equal_list()</methodname> call would look like
+    this:</para>
+
+    <programlisting>
+query &lt;&lt; "select * from stock where " &lt;&lt;
+    res[0].equal_list(" and ", false, false, true, true, false);</programlisting>
+
+    <para>It&rsquo;s a little more verbose, as you can see. And if you want
+    to get really complicated, use the vector form:</para>
+
+    <programlisting>
+vector&lt;bool&gt; v(5, false);
+v[stock_weight] = true;
+v[stock_price] = true;
+query &lt;&lt; "select * from stock where " &lt;&lt;
+    res[0].equal_list(" and ", v);</programlisting>
+
+    <para>This form makes the most sense if you are building many other
+    queries, and so can re-use that vector object.</para>
+
+    <para>Many of these methods accept manipulators and custom
+    delimiters. The defaults are suitable for building SQL queries, but
+    if you&rsquo;re using these methods in a different context, you may
+    need to override these defaults. For instance, you could use these
+    methods to dump data to a text file using different delimiters and
+    quoting rules than SQL.</para>
+
+    <para>At this point, we&rsquo;ve seen all the major aspects of the
+    SSQLS feature. The final sections of this chapter look at some of
+    the peripheral aspects.</para>
+  </sect2>
+
+
+  <sect2 id="ssqls-field-names">
+    <title>Having Different Field Names in C++ and SQL</title>
+
+    <para>There&rsquo;s a more advanced SSQLS creation macro,
+    which all the others are built on top of. Currently, the only
+    feature it adds over what&rsquo;s described above is that it
+    lets you name your SSQLS fields differently from the names
+    used by the database server. Perhaps you want to use <ulink
+    url="http://en.wikipedia.org/wiki/Hungarian_notation">Hungarian
+    notation</ulink> in your C++ program without changing the SQL
+    database schema:</para>
+
+    <programlisting>
+sql_create_complete_5(stock, 1, 5,   
+    mysqlpp::sql_char, item, "m_sItem",
+    mysqlpp::sql_bigint, num, "m_nNum",
+    mysqlpp::sql_double, weight, "m_fWeight",
+    mysqlpp::sql_decimal, price, "m_fPrice",
+    mysqlpp::sql_date, sdate, "m_Date")</programlisting>
+  </sect2>
+
+
+  <sect2 id="ssqls-pretty">
+    <title>Expanding SSQLS Macros</title>
+
+    <para>If you ever need to see the code that a given
+    SSQLS declaration expands out to, use the utility
+    <filename>doc/ssqls-pretty</filename>, like so:</para>
+
+    <programlisting>
+doc/ssqls-pretty &lt; myprog.cpp |less</programlisting>
+
+    <para>This Perl script locates the first SSQLS declaration in that
+    file, then uses the C++ preprocessor to expand that macro. (The
+    script assumes that your system&rsquo;s preprocessor is called
+    <filename>cpp</filename>, and that its command line interface
+    follows Unix conventions.)</para>
+
+    <para>If you run it from the top MySQL++ directory, as shown above,
+    it will use the header files in the distribution&rsquo;s
+    <filename>lib</filename> subdirectory. Otherwise, it assumes the
+    MySQL++ headers are in their default location,
+    <filename>/usr/include/mysql++</filename>. If you want to use
+    headers in some other location, you&rsquo;ll need to change the
+    directory name in the <command>-I</command> flag at the top of the
+    script.</para>
+  </sect2>
+
+
+  <sect2 id="ssqls-customization">
+    <title>Customizing the SSQLS Mechanism</title>
+
+    <para>The SSQLS header <filename>ssqls.h</filename> is automatically
+    generated by the Perl script <filename>ssqls.pl</filename>. Although
+    it is possible to change this script to get additional
+    functionality, most of the time it&rsquo;s better to just derive a
+    custom class from the stock SSQLS and add your additional
+    functionality that way.</para>
+
+    <para>That said, <filename>ssqls.pl</filename> does have a few
+    configurables you might want to tweak.</para>
+
+    <para>The first configurable value sets the maximum number of data
+    members allowed in an SSQLS. It&rsquo;s 25 out of the box, set by
+    the <varname>$max_data_members</varname> variable at the top of
+    <filename>ssqls.pl</filename>. Beware, making this value larger
+    increases the size of <filename>ssqls.h</filename> exponentially;
+    this will increase compile time, and can even expose limits in your
+    compiler. Before you increase this value, take a good, hard look at
+    your database schema and ask if it&rsquo;s really the best design.
+    Almost always, having so many columns is a sign that you need to
+    refactor the table.</para>
+
+    <para>The second configurable is the default floating point
+    precision used for comparison. As described above (<xref
+    linkend="ssqls-compare-init"/>) SSQLSes can be compared for
+    equality. The only place this is tricky is with floating-point
+    numbers, since rounding errors can make two &ldquo;equal&rdquo;
+    values compare as distinct. Since exact comparison makes no sense
+    with floating-point values, MySQL++ lets you specify the precision
+    you want it to use. If the difference between two values is under a
+    given threshold, MySQL++ considers the values equal. The default
+    threshold is 0.00001. This threshold works well for
+    &ldquo;human&rdquo; scale values, but because of the way
+    floating-point numbers work, it can be wildly inappropriate for very
+    large or very small quantities like those used in scientific
+    applications.</para>
+
+    <para>There are actually two ways to change this threshold. If you
+    need a different system-wide default, edit
+    <filename>ssqls.pl</filename> and change the
+    <varname>$fp_min_delta</varname> variable at the top of the file,
+    then rebuild <filename>ssqls.h</filename> as described below. If you
+    need different thresholds per file or per project, it&rsquo;s better
+    to set the C macro <varname>MYSQLPP_FP_MIN_DELTA</varname> instead.
+    The Perl variable sets this macro&rsquo;s default; if you give a
+    different value before #including <filename>ssqls.h</filename>, it
+    will use that instead.</para>
+
+    <para>To rebuild <filename>ssqls.h</filename> after changing
+    <filename>ssqls.pl</filename>, you&rsquo;ll need a Perl interpreter.
+    The only modern Unixy system I&rsquo;m aware of where Perl
+    isn&rsquo;t installed by default is Cygwin, and it&rsquo;s just a
+    <filename>setup.exe</filename> choice away there. You&rsquo;ll
+    probably only have to download and install a Perl interpreter if
+    you&rsquo;re on Windows and don&rsquo;t want to use Cygwin.</para>
+
+    <para>If you&rsquo;re on a system that uses autoconf, building
+    MySQL++ automatically updates <filename>ssqls.h</filename> any time
+    <filename>ssqls.pl</filename> changes. Otherwise, you&rsquo;ll need
+    to run the Perl interpreter by hand:</para>
+
+    <screen>c:\mysql++> cd lib
+c:\lib> perl ssqls.pl</screen>
+  </sect2>
+
+
+  <sect2 id="ssqls-blob">
+    <title>SSQLS and BLOB Columns</title>
+
+    <para>It takes special care to use SSQLS with BLOB columns.
+    It&rsquo;s safest to declare the SSQLS field as of type
+    <classname>mysqlpp::sql_blob</classname>. This is currently a
+    typedef alias for <ulink type="classref"
+    url="String">String</ulink>, which is the form the data is in just
+    before the SSQLS mechanism populates the structure. Thus, when the
+    data is copied from the internal MySQL++ data structures into your
+    SSQLS, you get a direct copy of the <classname>String</classname>
+    object&rsquo;s contents, without interference.</para>
+
+    <para>Because C++ strings handle binary data just fine, you might
+    think you can use <classname>std::string</classname> instead of
+    <classname>sql_blob</classname>, but the current design of
+    <classname>String</classname> converts to
+    <classname>std::string</classname> via a C string. As a result, the
+    BLOB data is truncated at the first embedded null character during
+    population of the SSQLS. There&rsquo;s no way to fix that without
+    completely redesigning either <classname>String</classname> or the
+    SSQLS mechanism.</para>
+
+    <para>The <classname>sql_blob</classname> typedef may be changed to
+    alias a different type in the future, so using it instead of
+    <classname>String</classname> ensures that your code tracks these
+    library changes automatically. Besides,
+    <classname>String</classname> is only intended to be an internal
+    mechanism within MySQL++. The only reason the layering is so thin
+    here is because it&rsquo;s the only way to prevent BLOB data from
+    being corrupted while avoiding that looming redesign effort.</para>
+
+    <para>You can see this technique in action in the
+    <filename>cgi_jpeg</filename> example:</para>
+
+    <programlisting><xi:include href="cgi_jpeg.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+  </sect2>
+
+
+  <sect2 id="ssqls-vc2003">
+    <title>SSQLS and Visual C++ 2003</title>
+
+    <para>SSQLS works on all platforms supported by MySQL++ except for
+    Visual C++ 2003. (Because the rest of MySQL++ works just fine with
+    Visual C++ 2003, we haven&rsquo;t removed this platform from the
+    supported list entirely.)</para>
+
+    <para>If you do need SSQLS and are currently on Visual C++ 2003, you
+    have these options:</para>
+
+    <orderedlist>
+      <listitem><para>The simplest option is to upgrade to a newer
+      version of Visual C++. The compiler limitations that break SSQLS
+      are all fixed in Visual C++ 2005 and newer. <ulink
+      url="http://www.microsoft.com/express/vc/">Visual C++
+      Express</ulink> is free and is apparently here to stay; coupled
+      with the free <ulink url="http://wxwidgets.org/">wxWidgets</ulink>
+      library, it lacks little compared to Visual C++ Professional.  A
+      bonus of using wxWidgets is that it&rsquo;s cross-platform and
+      better-supported than MFC.</para></listitem>
+
+      <listitem><para>If you can&rsquo;t upgrade your compiler, you may
+      be able to downgrade to MySQL++ v2.<emphasis>x</emphasis>.  The
+      SSQLS feature in these older versions worked with Visual C++ 2003,
+      but didn&rsquo;t let you use a given SSQLS in more than one module
+      in a program. If you can live with that limitation and have a Perl
+      interpreter on your system, you can re-generate
+      <filename>lib/ssqls.h</filename> to remove the multiple-module
+      SSQLS support. To do this, you run the command <command>perl
+      ssqls.pl -v</command> from within MySQL++&rsquo;s
+      <filename>lib</filename> subdirectory before you build and install
+      the library.</para></listitem>
+
+      <listitem><para>There&rsquo;s <ulink
+      url="http://svn.gna.org/viewcvs/*checkout*/mysqlpp/trunk/Wishlist">a
+      plan</ulink> to replace the current SSQLS mechanism with an
+      entirely new code base. Although this is being done primary to get
+      new features that are too difficult to add within the current
+      design, it also means we&rsquo;ll have the chance to test
+      step-by-step along the way that we don&rsquo;t reintroduce code
+      that Visual C++ 2003 doesn&rsquo;t support. This may happen
+      without you doing anything, but if there&rsquo;s someone on the
+      team who cares about this, that will naturally increase the
+      chances that it does happen.</para></listitem>
+    </orderedlist>
+  </sect2>
+</sect1>

ADDED   doc/userman/threads.dbx
Index: doc/userman/threads.dbx
==================================================================
--- /dev/null
+++ doc/userman/threads.dbx
@@ -0,0 +1,323 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="threads">
+  <title>Using MySQL++ in a Multithreaded Program</title>
+
+  <para>MySQL++ is not &ldquo;thread safe&rdquo; in any
+  meaningful sense. MySQL++ contains very little code that
+  actively prevents trouble with threads, and all of it is
+  optional. We have done some work in MySQL++ to make thread
+  safety <emphasis>achievable</emphasis>, but it doesn&rsquo;t come
+  for free.</para>
+
+  <para>The main reason for this is that MySQL++ is
+  generally I/O-bound, not processor-bound. That is, if
+  your program&rsquo;s bottleneck is MySQL++, the ultimate
+  cause is usually the I/O overhead of using a client-server
+  database. Doubling the number of threads will just let your
+  program get back to waiting for I/O twice as fast. Since <ulink
+  url="http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1.pdf">threads
+  are evil</ulink> and generally can&rsquo;t help MySQL++, the only
+  optional thread awareness features we turn on in the shipping
+  version of MySQL++ are those few that have no practical negative
+  consequences. Everything else is up to you, the programmer, to
+  evaluate and enable as and when you need it.</para>
+
+  <para>We&rsquo;re going to assume that you either agree with these
+  views but find yourself needing to use threads for some other
+  reason, or are foolishly disregarding these facts and are going to
+  use threads anyway. Our purpose here is limited to setting down
+  the rules for avoiding problems with MySQL++ in a multi-threaded
+  program. We won&rsquo;t go into the broader issues of thread safety
+  outside the scope of MySQL++. You will need a grounding in threads
+  in general to get the full value of this advice.</para>
+
+  <sect2 id="thread-build">
+    <title>Build Issues</title>
+
+    <para>Before you can safely use MySQL++ with threads, there are
+    several things you must do to get a thread-aware build:</para>
+
+    <orderedlist>
+      <listitem>
+        <para><emphasis>Build MySQL++ itself with thread awareness
+        turned on.</emphasis></para>
+
+        <para>On Linux, Cygwin and Unix (OS X, *BSD, Solaris...),
+        pass the <computeroutput>--enable-thread-check</computeroutput>
+        flag to the <filename>configure</filename> script. Beware, this
+        is only a request to the <filename>configure</filename> script
+        to look for thread support on your system, not a requirement
+        to do or die: if the script doesn&rsquo;t find what it needs
+        to do threading, MySQL++ will just get built without thread
+        support. See <filename>README-Unix.txt</filename> for more
+        details.</para>
+
+        <para>On Windows, if you use the Visual C++ project files or
+        the MinGW Makefile that comes with the MySQL++ distribution,
+        threading is always turned on, due to the nature of
+        Windows.</para>
+
+        <para>If you build MySQL++ in some other way, such as with
+        Dev-Cpp (based on MinGW) you&rsquo;re on your own to enable
+        thread awareness.</para>
+      </listitem>
+
+      <listitem>
+        <para><emphasis>Link your program to a thread-aware build of the
+        MySQL C API library.</emphasis></para>
+
+        <para>If you use a binary distribution of MySQL on Unixy
+        systems, you usually get two different versions of the MySQL
+        C API library, one with thread support and one without. These
+        are typically called <filename>libmysqlclient</filename> and
+        <filename>libmysqlclient_r</filename>, the latter being the
+        thread-safe one. (The &ldquo;<filename>_r</filename>&rdquo;
+        means reentrant.)</para>
+
+        <para>If you&rsquo;re using the Windows binary distribution of
+        MySQL, there are two versions of the client library, but both
+        are thread aware. One just has debugging symbols, and the other
+        doesn&rsquo;t. See <filename>README-Visual-C++.txt</filename>
+        or <filename>README-MinGW.txt</filename> for details.</para>
+
+        <para>If you build MySQL from source, you might only get
+        one version of the MySQL C API library, and it can have
+        thread awareness or not, depending on your configuration
+        choices. This is the case with Cygwin, where you currently
+        have no choice but to build the C API library from source. (See
+        <filename>README-Cygwin.txt</filename>.)</para>
+      </listitem>
+
+      <listitem>
+        <para><emphasis>Enable threading in your program&rsquo;s build
+        options.</emphasis></para>
+
+        <para>This is different for every platform, but it&rsquo;s
+        usually the case that you don&rsquo;t get thread-aware builds
+        by default. Depending on the platform, you might need to change
+        compiler options, linker options, or both. See your development
+        environment&rsquo;s documentation, or study how MySQL++ itself
+        turns on thread-aware build options when requested.</para>
+      </listitem>
+    </orderedlist>
+  </sect2>
+
+
+  <sect2 id="thread-conn-mgmt">
+    <title>Connection Management</title>
+
+    <para>The MySQL C API underpinning MySQL++ does not allow multiple
+    concurrent queries on a single connection. You can run into this
+    problem in a single-threaded program, too, which is why we cover the
+    details elsewhere, in <xref linkend="concurrentqueries"/>.
+    It&rsquo;s a thornier problem when using threads, though.</para>
+
+    <para>The simple fix is to just create a separarate <ulink
+    url="Connection" type="classref"/> object for each thread
+    that needs to make database queries. This works well if you
+    have a small number of threads that need to make queries, and
+    each thread uses its connection often enough that the server
+    doesn&rsquo;t time out waiting for queries.<footnote><para>By
+    default, current MySQL servers have an 8 hour idle timeout on
+    connections. It&rsquo;s a configuration option, though, so your
+    server may be set differently.</para></footnote></para>
+
+    <para>If you have lots of threads or the frequency of queries is
+    low, the connection management overhead will be excessive. To avoid
+    that, we created the <ulink url="ConnectionPool" type="classref"/>
+    class. It manages a pool of <classname>Connection</classname>
+    objects like library books: a thread checks one out, uses it,
+    and then returns it to the pool as soon as it&rsquo;s done with
+    it. This keeps the number of active connections low.</para>
+
+    <para><classname>ConnectionPool</classname> has three
+    methods that you need to override in a subclass to
+    make it concrete: <methodname>create()</methodname>,
+    <methodname>destroy()</methodname>, and
+    <methodname>max_idle_time()</methodname>. These overrides let
+    the base class delegate operations it can&rsquo;t successfully do
+    itself to its subclass. The <classname>ConnectionPool</classname>
+    can&rsquo;t know how to <methodname>create()</methodname>
+    the <classname>Connection</classname> objects, because that
+    depends on how your program gets login parameters, server
+    information, etc.  <classname>ConnectionPool</classname>
+    also makes the subclass <methodname>destroy()</methodname>
+    the <classname>Connection</classname> objects it created; it
+    could assume that they&rsquo;re simply allocated on the heap
+    with <methodname>new</methodname>, but it can&rsquo;t be sure,
+    so the base class delegates destruction, too. Finally, the base
+    class can&rsquo;t know what the connection idle timeout policy
+    in the client would make the most sense, so it asks its subclass
+    via the <methodname>max_idle_time()</methodname> method.</para>
+
+    <para><classname>ConnectionPool</classname> also allows you to
+    override <methodname>release()</methodname>, if needed. For simple
+    uses, it&rsquo;s not necessary to override this.</para>
+
+    <para>In designing your <classname>ConnectionPool</classname>
+    derivative, you might consider making it a Singleton (see Gamma
+    et al.), since there should only be one pool in a program.</para>
+
+    <para>Here is an example showing how to use connection pools with
+    threads:</para>
+
+    <programlisting><xi:include href="cpool.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>The example works with both Windows native
+    threads and with POSIX threads.<footnote><para>The file
+    <filename>examples/threads.h</filename> contains a few macros and
+    such to abstract away the differences between the two threading
+    models.</para></footnote> Because thread-enabled builds are only
+    the default on Windows, it&rsquo;s quite possible for this program
+    to do nothing on other platforms. See above for instructions on
+    enabling a thread-aware build.</para>
+
+    <para>If you write your code without checks for thread support
+    like you see in the code above and link it to a build of MySQL++
+    that isn&rsquo;t thread-aware, it will still try to run. The
+    threading mechanisms fall back to a single-threaded mode when
+    threads aren&rsquo;t available. A particular danger is that the
+    mutex lock mechanism used to keep the pool&rsquo;s internal data
+    consistent while multiple threads access it will just quietly
+    become a no-op if MySQL++ is built without thread support. We do
+    it this way because we don&rsquo;t want to make thread support
+    a MySQL++ prerequisite. And, although it would be of limited
+    value, this lets you use <classname>ConnectionPool</classname>
+    in single-threaded programs.</para>
+
+    <para>You might wonder why we don&rsquo;t just work around
+    this weakness in the C API transparently in MySQL++ instead of
+    suggesting design guidelines to avoid it. We&rsquo;d like to do
+    just that, but how?</para>
+
+    <para>If you consider just the threaded case, you could argue for
+    the use of mutexes to protect a connection from trying to execute
+    two queries at once. The cure is worse than the disease: it turns a
+    design error into a performance sap, as the second thread is blocked
+    indefinitely waiting for the connection to free up. Much better to
+    let the program get the &ldquo;Commands out of sync&rdquo; error,
+    which will guide you to this section of the manual, which tells you
+    how to avoid the error with a better design.</para>
+
+    <para>Another option would be to bury
+    <classname>ConnectionPool</classname> functionality within MySQL++
+    itself, so the library could create new connections at need.
+    That&rsquo;s no good because the above example is the most complex
+    in MySQL++, so if it were mandatory to use connection pools, the
+    whole library would be that much more complex to use. The whole
+    point of MySQL++ is to make using the database easier. MySQL++
+    offers the connection pool mechanism for those that really need it,
+    but an option it must remain.</para>
+  </sect2>
+
+
+  <sect2 id="thread-helpers">
+    <title>Helper Functions</title>
+
+    <para><classname>Connection</classname> has several thread-related
+    static methods you might care about when using MySQL++ with
+    threads.</para>
+
+    <para>You can call
+    <methodname>Connection::thread_aware()</methodname> to
+    determine whether MySQL++ and the underlying C API library
+    were both built to be thread-aware. Again, I stress that thread
+    <emphasis>awareness</emphasis> is not the same thing as thread
+    <emphasis>safety</emphasis>: it&rsquo;s still up to you to
+    make your code thread-safe. If this method returns true, it
+    just means it&rsquo;s <emphasis>possible</emphasis> to achieve
+    thread-safety.</para>
+
+    <para>If your program&rsquo;s connection-management strategy allows
+    a thread to use a <classname>Connection</classname> object that
+    another thread created before it creates a connection of its own,
+    you must call <methodname>Connection::thread_start()</methodname>
+    from that thread before it does anything with MySQL++. If a
+    thread creates a new connection before it uses a connection
+    created by another thread, though, it doesn&rsquo;t need to call
+    <methodname>Connection::thread_start()</methodname> because the
+    per-thread resources this allocates are implicitly created upon
+    creation of a connection if necessary.</para>
+
+    <para>This is why the simple
+    <classname>Connection</classname>-per-thread strategy
+    works: each thread that uses MySQL++ creates a connection
+    in that thread, implicitly allocating the per-thread
+    resources at the same time. You never need to call
+    <methodname>Connection::thread_start()</methodname> in this
+    instance. It&rsquo;s not harmful to call this function, just
+    unnecessary.</para>
+
+    <para>A good counterexample is using
+    <classname>ConnectionPool</classname>: you probably do need
+    to call <methodname>Connection::thread_start()</methodname>
+    at the start of each worker thread because you can&rsquo;t
+    usually tell whether you&rsquo;re getting a new connection
+    from the pool, or reusing one that another thread returned
+    to the pool after allocating it. It&rsquo;s possible to
+    conceive of situations where you can guarantee that each pool
+    user always allocates a fresh connection the first time it
+    calls <methodname>ConnectionPool::grab()</methodname>,
+    but thread programming is complex enough that
+    it&rsquo;s best to take the safe path and always call
+    <methodname>Connection::thread_start()</methodname> early in each
+    worker thread.</para>
+
+    <para>Finally, there&rsquo;s the complementary method,
+    <methodname>Connection::thread_end()</methodname>. Strictly
+    speaking, it&rsquo;s not <emphasis>necessary</emphasis> to call
+    this. The per-thread memory allocated by the C API is small,
+    it doesn&rsquo;t grow over time, and a typical thread is going
+    to need this memory for its entire run time. Memory debuggers
+    aren&rsquo;t smart enough to know all this, though, so they will
+    gripe about a memory leak unless you call this from each thread
+    that uses MySQL++ before that thread exits.</para>
+
+    <para>Although its name suggests otherwise,
+    <methodname>Connection::thread_id()</methodname> has nothing to
+    do with anything in this chapter.</para>
+  </sect2>
+
+
+  <sect2 id="thread-data-sharing">
+    <title>Sharing MySQL++ Data Structures</title>
+
+    <para>We&rsquo;re in the process of making it safer to share
+    MySQL++&rsquo;s data structures across threads.</para>
+
+    <para>By way of illustration, let me explain a problem we had up
+    until MySQL++ v3.0. When you issue a database query that returns
+    rows, you also get information about the columns in each row. Since
+    the column information is the same for each row in the result set,
+    older versions of MySQL++ kept this information in the result set
+    object, and each <ulink url="Row" type="classref"/> kept a pointer
+    back to the result set object that created it so it could access
+    this common data at need. This was fine as long as each result set
+    object outlived the <classname>Row</classname> objects it returned.
+    It required uncommon usage patterns to run into trouble in this area
+    in a single-threaded program, but in a multi-threaded program it was
+    easy. For example, there&rsquo;s frequently a desire to let one
+    connection do the queries, and other threads process the results.
+    You can see how avoiding lifetime problems here would require a
+    careful locking strategy.</para>
+
+    <para>We got around this in MySQL++ v3.0 by giving these shared data
+    structures a lifetime independent of the result set object that
+    intitially creates it. These shared data structures stick around
+    until the last object needing them gets destroyed.</para>
+
+    <para>Although this is now a solved problem, I bring it up because
+    there are likely other similar lifetime and sequencing problems
+    waiting to be discovered inside MySQL++. If you would like to help
+    us find these, by all means, share data between threads willy-nilly.
+    We welcome your crash reports on the MySQL++ mailing list. But if
+    you&rsquo;d prefer to avoid problems, it&rsquo;s better to keep all
+    data about a query within a single thread. Between this and the
+    previous section&rsquo;s advice, you should be able to use threads
+    with MySQL++ without trouble.</para>
+  </sect2>
+</sect1>

ADDED   doc/userman/tquery.dbx
Index: doc/userman/tquery.dbx
==================================================================
--- /dev/null
+++ doc/userman/tquery.dbx
@@ -0,0 +1,224 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="tquery" xreflabel="Template Queries">
+  <title>Template Queries</title>
+
+  <para>Another powerful feature of MySQL++ is being able to set up
+  template queries. These are kind of like C&rsquo;s
+  <function>printf()</function> facility: you give MySQL++ a string
+  containing the fixed parts of the query and placeholders for the
+  variable parts, and you can later substitute in values into those
+  placeholders.</para>
+
+  <para>The following program demonstrates how to use this feature. This
+  is <filename>examples/tquery1.cpp</filename>:</para>
+
+  <programlisting><xi:include href="tquery1.txt" parse="text" 
+  xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+  <para>The line just before the call to
+  <methodname>query.parse()</methodname> sets the template, and the
+  parse call puts it into effect. From that point on, you can re-use
+  this query by calling any of several Query member functions that
+  accept query template parameters. In this example, we&rsquo;re using
+  <methodname>Query::execute()</methodname>.</para>
+
+  <para>Let&rsquo;s dig into this feature a little deeper.</para>
+
+
+  <sect2 id="tquery-setup">
+    <title>Setting up Template Queries</title>
+
+    <para>To set up a template query, you simply insert it into the
+    Query object, using numbered placeholders wherever you want to be
+    able to change the query. Then, you call the parse() function to
+    tell the Query object that the query string is a template query,
+    and it needs to parse it:</para>
+
+    <programlisting>
+query &lt;&lt; "select (%2:field1, %3:field2) from stock where %1:wheref = %0q:what";
+query.parse();</programlisting>
+
+    <para>The format of the placeholder is:</para>
+
+    <programlisting>
+%###(modifier)(:name)(:)</programlisting>
+
+    <para>Where &ldquo;###&rdquo; is a number up to three digits. It is
+    the order of parameters given to a <ulink type="classref"
+    url="SQLQueryParms"/> object, starting from 0.</para>
+
+    <para>&ldquo;modifier&rdquo; can be any one of the following:</para>
+
+    <blockquote>
+    <informaltable frame="none">
+    <tgroup cols="2">
+    <colspec colsep="1" rowsep="1"/>
+    <tbody>
+      <row>
+        <entry><emphasis role="bold">%</emphasis></entry>
+
+        <entry>Print an actual &ldquo;%&rdquo;</entry>
+      </row>
+
+      <row>
+        <entry><emphasis role="bold">""</emphasis></entry>
+
+        <entry>Don&rsquo;t quote or escape no matter what.</entry>
+      </row>
+
+      <row>
+        <entry><emphasis role="bold">q</emphasis></entry>
+
+        <entry>This will escape the item using the MySQL C API
+        function <ulink url="mysql-escape-string" type="mysqlapi"/>
+        and add single quotes around it as necessary, depending on
+        the type of the value you use.</entry>
+      </row>
+
+      <row>
+        <entry><emphasis role="bold">Q</emphasis></entry>
+
+        <entry>Quote but don&rsquo;t escape based on the same rules as
+        for &ldquo;q&rdquo;. This can save a bit of processing time if
+        you know the strings will never need quoting</entry>
+      </row>
+    </tbody>
+    </tgroup>
+    </informaltable>
+    </blockquote>
+
+    <para>&ldquo;:name&rdquo; is for an optional name which aids in
+    filling SQLQueryParms. Name can contain any alpha-numeric characters
+    or the underscore. You can have a trailing colon, which will be
+    ignored. If you need to represent an actual colon after the name,
+    follow the name with two colons. The first one will end the name and
+    the second one won&rsquo;t be processed.</para>
+  </sect2>
+
+
+  <sect2 id="tquery-parms">
+    <title>Setting the Parameters at Execution Time</title>
+
+    <para>To specify the parameters when you want to execute a query
+    simply use <methodname>Query::store(const SQLString &amp;parm0,
+    [..., const SQLString &amp;parm11])</methodname>. This type of
+    multiple overload also exists for
+    <methodname>Query::storein()</methodname>,
+    <methodname>Query::use()</methodname> and
+    <methodname>Query::execute()</methodname>. &ldquo;parm0&rdquo;
+    corresponds to the first parameter, etc. You may specify up to 25
+    parameters. For example:</para>
+
+    <programlisting>
+StoreQueryResult res = query.store("Dinner Rolls", "item", "item", "price")</programlisting>
+
+    <para>with the template query provided above would produce:</para>
+
+    <programlisting>
+select (item, price) from stock where item = "Dinner Rolls"</programlisting>
+
+    <para>The reason we didn&rsquo;t put the template parameters in
+    numeric order...</para>
+
+    <programlisting>
+select (%0:field1, %1:field2) from stock where %2:wheref = %3q:what</programlisting>
+
+    <para>...will become apparent shortly.</para>
+  </sect2>
+
+
+  <sect2 id="tquery-defaults">
+    <title>Default Parameters</title>
+
+    <para>The template query mechanism allows you to set default
+    parameter values. You simply assign a value for the parameter to the
+    appropriate position in the
+    <varname>Query::template_defaults</varname> array. You can refer to
+    the parameters either by position or by name:</para>
+
+    <programlisting>
+query.template_defaults[1] = "item";
+query.template_defaults["wheref"] = "item";</programlisting>
+
+    <para>Both do the same thing.</para>
+
+    <para>This mechanism works much like C++&rsquo;s default function
+    parameter mechanism: if you set defaults for the parameters at the
+    end of the list, you can call one of
+    <classname>Query</classname>&rsquo;s query execution methods without
+    passing all of the values. If the query takes four parameters and
+    you&rsquo;ve set defaults for the last three, you can execute the
+    query using as little as just one explicit parameter.</para>
+
+    <para>Now you can see why we numbered the template query parameters
+    the way we did a few sections earlier. We ordered them so that the
+    ones less likely to change have higher numbers, so we don&rsquo;t
+    always have to pass them. We can just give them defaults and take
+    those defaults when applicable. This is most useful when some
+    parameters in a template query vary less often than other
+    parameters. For example:</para>
+
+    <programlisting>
+query.template_defaults["field1"] = "item"; 
+query.template_defaults["field2"] = "price"; 
+StoreQueryResult res1 = query.store("Hamburger Buns", "item"); 
+StoreQueryResult res2 = query.store(1.25, "price"); </programlisting>
+
+    <para>This stores the result of the following queries in
+    <varname>res1</varname> and <varname>res2</varname>,
+    respectively:</para>
+
+    <programlisting>
+select (item, price) from stock where item = "Hamburger Buns"
+select (item, price) from stock where price = 1.25</programlisting>
+
+    <para>Default parameters are useful in this example because we have
+    two queries to issue, and parameters 2 and 3 remain the same for
+    both, while parameters 0 and 1 vary.</para>
+
+    <para>Some have been tempted into using this mechanism as a way to
+    set all of the template parameters in a query:</para>
+
+    <programlisting>
+query.template_defaults["what"] = "Hamburger Buns";
+query.template_defaults["wheref"] = "item";
+query.template_defaults["field1"] = "item"; 
+query.template_defaults["field2"] = "price"; 
+StoreQueryResult res1 = query.store();</programlisting>
+
+    <para>This can work, but it is <emphasis>not designed to</emphasis>.
+    In fact, it&rsquo;s known to fail horribly in one common case. You
+    will not get sympathy if you complain on the mailing list about it
+    not working. If your code doesn&rsquo;t actively reuse at least one
+    of the parameters in subsequent queries, you&rsquo;re abusing
+    MySQL++, and it is likely to take its revenge on you.</para>
+  </sect2>
+
+
+  <sect2 id="tquery-errors">
+    <title>Error Handling</title>
+
+    <para>If for some reason you did not specify all the parameters when
+    executing the query and the remaining parameters do not have their
+    values set via <varname>Query::template_defaults</varname>, the
+    query object will throw a <ulink type="classref"
+    url="BadParamCount"/> object. If this happens, you can get an
+    explanation of what happened by calling
+    <methodname>BadParamCount::what()</methodname>, like so:</para>
+
+    <programlisting>
+query.template_defaults["field1"] = "item"; 
+query.template_defaults["field2"] = "price"; 
+StoreQueryResult res = query.store(1.25); </programlisting>
+
+    <para>This would throw <classname>BadParamCount</classname> because
+    the <varname>wheref</varname> is not specified.</para>
+
+    <para>In theory, this exception should never be thrown. If the
+    exception is thrown it probably a logic error in your
+    program.</para>
+  </sect2>
+</sect1>

ADDED   doc/userman/tutorial.dbx
Index: doc/userman/tutorial.dbx
==================================================================
--- /dev/null
+++ doc/userman/tutorial.dbx
@@ -0,0 +1,1269 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="tutorial" xreflabel="Tutorial">
+  <title>Tutorial</title>
+
+  <para>This tutorial is meant to give you a jump start in using
+  MySQL++. While it is a very complicated and powerful library,
+  it&rsquo;s possible to make quite functional programs without tapping
+  but a fraction of its power. This section will introduce you to the
+  most useful fraction.</para>
+
+  <para>This tutorial assumes you know C++ fairly well, in particular
+  the Standard Template Library (STL) and exceptions.</para>
+
+
+  <sect2 id="examples">
+    <title>Running the Examples</title>
+
+    <para>All of the examples are complete running programs. If you
+    built the library from source, the examples should have been built
+    as well. If you use RPMs instead, the example programs&rsquo; source
+    code and a simplified <filename>Makefile</filename> are in the
+    <filename>mysql++-devel</filename> package. They are typically
+    installed in
+    <filename>/usr/share/doc/mysql++-devel-*/examples</filename>, but it
+    can vary on different Linuxes.</para>
+
+    <para>Before you get started, please read through any of the
+    <filename>README*</filename> files included with the MySQL++
+    distribution that are relevant to your platform. We won&rsquo;t
+    repeat all of that here.</para>
+
+    <para>Most of the examples require a test database, created by
+    <filename>resetdb</filename>. You can run it like so:</para>
+
+    <screen>resetdb [-s server_addr] [-u user] [-p password]</screen>
+
+    <para>Actually, there&rsquo;s a problem with that. It assumes that
+    the MySQL++ library is already installed in a directory that the
+    operating system&rsquo;s dynamic linker can find. (MySQL++ is almost
+    never built statically.) Unless you&rsquo;re installing from RPMs,
+    you&rsquo;ve had to build the library from source, and you should
+    run at least a few of the examples before installing the library to
+    be sure it&rsquo;s working correctly. Since your operating
+    system&rsquo;s dynamic linkage system can&rsquo;t find the MySQL++
+    libraries without help until they&rsquo;re installed, we&rsquo;ve
+    created a few helper scripts to help run the examples.</para>
+
+    <para>MySQL++ comes with the <filename>exrun</filename> shell script
+    for Unixy systems, and the <filename>exrun.bat</filename> batch file
+    for Windows. You pass the example program and its arguments to the
+    <filename>exrun</filename> helper, which sets up the library search
+    path so that it will find the as-yet uninstalled version of the
+    MySQL++ library first. So on a Unixy system, the above command
+    becomes:</para>
+
+    <screen>./exrun resetdb [-s server_addr] [-u user] [-p password]</screen>
+    
+    <para>See <filename>README.examples</filename> for more
+    details.</para>
+
+    <para>All of the program arguments are optional.</para>
+
+    <para>If you don&rsquo;t give <option>-s</option>, the underlying
+    MySQL C API assumes the server is on the local machine.  Depending
+    on how the C API library and the server are configured, it can use
+    any of several different IPC methods to contact the server. You can
+    instead specify how to contact the server yourself, with the method
+    depending on the value you give for the server address:</para>
+
+    <itemizedlist>
+      <listitem>
+        <para><emphasis>localhost</emphasis> &mdash; this is the
+        default; it doesn&rsquo;t buy you anything</para>
+      </listitem>
+
+      <listitem>
+        <para>On Windows, a simple period tells the underlying MySQL C
+        API to use named pipes, if it&rsquo;s available.</para>
+      </listitem>
+
+      <listitem>
+        <para><emphasis>172.20.0.252:12345</emphasis>
+        &mdash; this would connect to IP address
+        <computeroutput>172.20.0.252</computeroutput> on TCP port
+        <computeroutput>12345</computeroutput>.</para>
+      </listitem>
+
+      <listitem>
+        <para><emphasis>my.server.name:svc_name</emphasis> &mdash; this
+        would first look up TCP service name
+        <computeroutput>svc_name</computeroutput> in your system&rsquo;s
+        network services database (<filename>/etc/services</filename> on
+        Unixy systems, and something like
+        <filename>c:\windows\system32\drivers\etc\services</filename> on
+        modern Windows variants). If it finds an entry for the service,
+        it then tries to connect to that port on the domain name
+        given.</para>
+      </listitem>
+    </itemizedlist>
+
+    <para>You can mix symbolic host and service names in any
+    combination. If the name doesn&rsquo;t contain a colon, it uses the
+    default port, 3306.</para>
+
+    <para>If you don&rsquo;t give <option>-u</option>, it assumes your
+    user name on the local machine is the same as your user name on the
+    database server.</para>
+
+    <para>If you don&rsquo;t give <option>-p</option>, it will assume
+    the MySQL user doesn&rsquo;t have a password, which had better not
+    be the case.  It&rsquo;s a wild world out there; play safe,
+    kids.</para>
+
+    <para>A typical invocation is:</para>
+
+    <screen>exrun.bat resetdb -u mydbuser -p nunyabinness</screen>
+
+    <para>For <filename>resetdb</filename>, the user name needs to be
+    for an account with permission to create databases. Once the
+    database is created, you can use any account that has read and write
+    permissions for the sample database,
+    <filename>mysql_cpp_data</filename>.</para>
+
+    <para>You may also have to re-run <filename>resetdb</filename>
+    after running some of the other examples, as they change the
+    database.</para>
+  </sect2>
+
+
+  <sect2 id="simple">
+    <title>A Simple Example</title>
+
+    <para>The following example demonstrates how to open a connection,
+    execute a simple query, and display the results. This is
+    <filename>examples/simple1.cpp</filename>:</para>
+
+    <programlisting><xi:include href="simple1.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>This example simply gets the entire "item" column from the
+    example table, and prints those values out.</para>
+
+    <para>Notice that MySQL++&rsquo;s <ulink type="classref"
+    url="StoreQueryResult"/> derives from
+    <classname>std::vector</classname>, and <ulink type="classref"
+    url="Row"/> provides an interface that makes it a
+    <classname>vector</classname> work-alike. This means you can access
+    elements with subscript notation, walk through them with iterators,
+    run STL algorithms on them, etc.</para>
+
+    <para><classname>Row</classname> provides a little more in this area
+    than a plain old <classname>vector</classname>: you can also access
+    fields by name using subscript notation.</para>
+
+    <para>The only thing that isn&rsquo;t explicit in the code above is
+    that we delegate command line argument parsing to
+    <function>parse_command_line()</function> in the
+    <filename>excommon</filename> module. This function exists to give
+    the examples a consistent interface, not to hide important details.
+    You can treat it like a black box: it takes <varname>argc</varname>
+    and <varname>argv</varname> as inputs and sends back database
+    connection parameters.</para>
+  </sect2>
+
+
+  <sect2 id="simple2">
+    <title>A More Complicated Example</title>
+
+    <para>The <filename>simple1</filename> example above was pretty
+    trivial. Let&rsquo;s get a little deeper. Here is
+    <filename>examples/simple2.cpp</filename>:</para>
+
+    <programlisting><xi:include href="simple2.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>The main point of this example is that we&rsquo;re accessing
+    fields in the row objects by name, instead of index. This is slower,
+    but obviously clearer. We&rsquo;re also printing out the entire
+    table, not just one column.</para>
+  </sect2>
+
+
+  <sect2 id="headers">
+    <title>#including MySQL++ Headers</title>
+
+    <para>You&rsquo;ll notice above that we&rsquo;re including
+    <filename>mysql++.h</filename> in the examples. There are many
+    headers in MySQL++, but this brings in all but one of them for you.
+    MySQL++ has a pretty cohesive design: it doesn&rsquo;t have very
+    many pieces that are truly independent of the others. So,
+    there&rsquo;s not much advantage in including the few headers you
+    think you need individually: you&rsquo;re likely to also drag in all
+    the rest indirectly.</para>
+
+    <para>The one header that <filename>mysql++.h</filename>
+    doesn&rsquo;t
+    bring in for you is <filename>ssqls.h</filename>, which is only
+    useful if you use the optional <xref linkend="ssqlsintro"/>
+    feature.</para>
+
+    <para>By default on Unixy systems, MySQL++ installs its headers into
+    a <filename>mysql++</filename> subdirectory of one of the main
+    system include directories, either <filename>/usr/include</filename>
+    or <filename>/usr/local/include</filename>. Since it&rsquo;s typical
+    for either or both of these directories to be in your
+    program&rsquo;s include path already, you might be wondering if you
+    can include the main MySQL++ header like this:</para>
+
+    <programlisting>#include &lt;mysql++/mysql++.h&gt;</programlisting>
+
+    <para>The answer is, yes you can. You don&rsquo;t need to do anything
+    special to make it work.</para>
+
+    <para>Since MySQL is usually installed in much the same way
+    (<filename>/usr/include/mysql</filename> is common, for example),
+    you might then ask if you can get away without having the MySQL C
+    API header directory to your program&rsquo;s include path. You can,
+    but <filename>mysql++.h</filename> requires a little help from your
+    program to find the C API headers when you do this:</para>
+
+    <programlisting>#define MYSQLPP_MYSQL_HEADERS_BURIED
+#include &lt;mysql++/mysql++.h&gt;</programlisting>
+
+    <para>This tells it to prefix all includes for C API headers with
+    <filename>mysql/</filename>.</para>
+  </sect2>
+
+
+  <sect2 id="exceptions" xreflabel="exceptions">
+    <title>Exceptions</title>
+
+    <para>By default, MySQL++ uses exceptions to signal errors. Most
+    of the examples have a full set of exception handlers. This is
+    worthy of emulation.</para>
+
+    <para>All of MySQL++&rsquo;s custom exceptions
+    derive from a common base class, <ulink type="classref"
+    url="Exception"/>. That in turn derives from Standard C++&rsquo;s
+    <classname>std::exception</classname> class. Since the library
+    can indirectly cause exceptions to come from the Standard
+    C++ Library, it&rsquo;s possible to catch all exceptions from
+    MySQL++ by just catching <classname>std::exception</classname>.
+    However, it&rsquo;s better to have individual catch blocks
+    for each of the concrete exception types that you expect, and
+    add a handler for either <classname>Exception</classname>
+    or <classname>std::exception</classname> to act as a
+    &ldquo;catch-all&rdquo; for unexpected exceptions.</para>
+
+    <para>Most of these exceptions are optional. When exceptions
+    are disabled on a MySQL++ object, it signals errors in some
+    other way, typically by returning an error code or setting
+    an error flag. Classes that support this feature derive from
+    <ulink type="classref" url="OptionalExceptions"/>. Moreover,
+    when such an object creates another object that also derives from
+    this interface, it passes on its exception flag. Since everything
+    flows from the <ulink type="classref" url="Connection"/> object,
+    disabling exceptions on it at the start of the program disables
+    all optional exceptions. You can see this technique at work in
+    the <filename>simple[1-3]</filename> examples, which keeps them,
+    well, simple.</para>
+
+    <para>Real-world code typically can&rsquo;t afford to lose
+    out on the additional information and control offered by
+    exceptions. But at the same time, it is still sometimes useful
+    to disable exceptions temporarily. To do this, put the section
+    of code that you want to not throw exceptions inside a block,
+    and create a <ulink type="classref" url="NoExceptions"/> object
+    at the top of that block. When created, it saves the exception
+    flag of the <classname>OptionalExceptions</classname> derivative
+    you pass to it, and then disables exceptions on it. When the
+    <classname>NoExceptions</classname> object goes out of scope
+    at the end of the block, it restores the exceptions flag to its
+    previous state:</para>
+
+    <programlisting>mysqlpp::Connection con(...); // exceptions enabled
+
+{
+  mysqlpp::NoExceptions ne(con);
+  if (!con.select_db("a_db_that_might_not_exist_yet")) {
+    // Our DB doesn't exist yet, so create and select it here; no need
+    // to push handling of this case way off in an exception handler.
+  }
+}</programlisting>
+
+    <para>When one <classname>OptionalExceptions</classname> derivative
+    passes its exceptions flag to another such object, it is only
+    passing a copy; the two objects&rsquo; flags operate independently.
+    There&rsquo;s no way to globally enable or disable this flag on
+    existing objects in a single call. If you&rsquo;re using the
+    <classname>NoExceptions</classname> feature and you&rsquo;re
+    still seeing optional exceptions thrown, you disabled exceptions
+    on the wrong object. The exception thrower could be unrelated to
+    the object you disabled exceptions on, it could be its parent,
+    or it could be a child created before you disabled optional
+    exceptions.</para>
+
+    <para>MySQL++ throws some exceptions unconditionally:</para>
+
+    <itemizedlist>
+      <listitem><para>The largest set of non-optional exceptions are
+      those from the Standard C++ Library. For instance, if your code
+      said &ldquo;<varname>row[21]</varname>&rdquo; on a row containing
+      only 5 fields, the <classname>std::vector</classname> underlying
+      the row object will throw an exception. (It will, that is, if it
+      conforms to the standard.) You might consider wrapping your
+      program&rsquo;s main loop in a try block catching
+      <classname>std::exception</classname>s, just in case you trigger
+      one of these exceptions.</para></listitem>
+
+      <listitem><para><ulink type="classref" url="String"/> will always
+      throw <ulink type="classref" url="BadConversion"/> when you ask it
+      to do an improper type conversion. For example, you&rsquo;ll get
+      an exception if you try to convert &ldquo;1.25&rdquo; to
+      <type>int</type>, but not when you convert &ldquo;1.00&rdquo; to
+      <type>int</type>. In the latter case, MySQL++ knows that it can
+      safely throw away the fractional part.</para></listitem>
+
+      <listitem><para>If you use template queries and don&rsquo;t pass
+      enough parameters when instantiating the template,
+      <classname>Query</classname> will throw a <ulink type="classref"
+      url="BadParamCount"/> exception.</para></listitem>
+
+      <listitem><para>If you use a C++ data type in a query
+      that MySQL++ doesn&rsquo;t know to convert to SQL, MySQL++
+      will throw a <ulink type="classref" url="TypeLookupFailed"/>
+      exception. It typically happens with <xref linkend="ssqls"/>,
+      especially when using data types other than the ones defined
+      in <filename>lib/sql_types.h</filename>.</para></listitem>
+    </itemizedlist>
+
+    <para>It&rsquo;s educational to modify the examples to force
+    exceptions. For instance, misspell a field name, use an out-of-range
+    index, or change a type to force a <classname>String</classname>
+    conversion error.</para>
+  </sect2>
+
+
+  <sect2 id="qescape" xreflabel="quoting and escaping">
+    <title>Quoting and Escaping</title>
+
+    <para>SQL syntax often requires certain data to be quoted. Consider
+    this query:</para>
+
+    <programlisting>
+SELECT * FROM stock WHERE item = 'Hotdog Buns' </programlisting>
+
+    <para>Because the string &ldquo;Hotdog Buns&rdquo; contains a space,
+    it must be quoted. With MySQL++, you don&rsquo;t have to add these
+    quote marks manually:</para>
+
+    <programlisting>
+string s = "Hotdog Buns";
+query &lt;&lt; "SELECT * FROM stock WHERE item = " &lt;&lt; quote_only &lt;&lt; s; </programlisting>
+
+    <para>That code produces the same query string as in the previous
+    example. We used the MySQL++ <type>quote_only</type> manipulator,
+    which causes single quotes to be added around the next item inserted
+    into the stream. This works for any type of data that can be
+    converted to MySQL++&rsquo;s <ulink type="classref"
+    url="SQLTypeAdapter">SQLTypeAdapter</ulink> type, plus the <ulink
+    type="classref" url="Set"/> template. <xref linkend="ssqlsintro"/>
+    also use these manipulators internally.</para>
+
+    <para>Quoting is pretty simple, but SQL syntax also often requires
+    that certain characters be &ldquo;escaped&rdquo;. Imagine if the
+    string in the previous example was &ldquo;Frank's Brand Hotdog
+    Buns&rdquo; instead. The resulting query would be:</para>
+
+    <programlisting>
+SELECT * FROM stock WHERE item = 'Frank's Brand Hotdog Buns' </programlisting>
+
+    <para>That&rsquo;s not valid SQL syntax. The correct syntax is:</para>
+
+    <programlisting>
+SELECT * FROM stock WHERE item = 'Frank''s Brand Hotdog Buns' </programlisting>
+
+    <para>As you might expect, MySQL++ provides that feature, too,
+    through its <type>escape</type> manipulator. But here, we want both
+    quoting and escaping. That brings us to the most widely useful
+    manipulator:</para>
+
+    <programlisting>
+string s = "Frank's Brand Hotdog Buns";
+query &lt;&lt; "SELECT * FROM stock WHERE item = " &lt;&lt; quote &lt;&lt; s; </programlisting>
+
+    <para>The <type>quote</type> manipulator both quotes strings and
+    escapes any characters that are special in SQL.</para>
+
+    <para>MySQL++ provides other manipulators as well. See the <ulink
+    url="../refman/manip_8h.html">manip.h</ulink> page in the <ulink
+    url="../refman/index.html">reference manual</ulink>.</para>
+
+    <para>It&rsquo;s important to realize that MySQL++&rsquo;s quoting
+    and escaping mechanism is type-aware. Manipulators have no effect
+    unless you insert the manipulator into a
+    <classname>Query</classname> or <ulink type="classref"
+    url="SQLQueryParms">SQLQueryParms</ulink> stream.
+    <footnote><para><classname>SQLQueryParms</classname> is used as a
+    stream only as an implementation detail within the library. End user
+    code simply sees it as a <classname>std::vector</classname>
+    derivative.</para></footnote> Also, values are only quoted and/or
+    escaped if they are of a data type that may need it. For example,
+    <ulink type="structref" url="Date">Date</ulink> must be quoted but
+    never needs to be escaped, and integer types need neither quoting
+    nor escaping. Manipulators are suggestions to the library, not
+    commands: MySQL++ will ignore these suggestions if it knows it
+    won&rsquo;t result in syntactically-incorrect SQL.</para>
+
+    <para>It&rsquo;s also important to realize that quoting and escaping
+    in <classname>Query</classname> streams and template queries is
+    never implicit.<footnote><para>By contrast, the
+    <classname>Query</classname> methods that take <xref
+    linkend="ssqlsintro"/> <emphasis>do</emphasis> add quotes and escape
+    strings implicitly. It can do this because SSQLS knows all the SQL
+    code and data types, so it never has to guess whether quoting or
+    escaping is appropriate.</para></footnote> You must use manipulators
+    and template query flags as necessary to tell MySQL++ where quoting
+    and escaping is necessary. It would be nice if MySQL++ could do
+    quoting and escaping implicitly based on data type, but this
+    isn&rsquo;t possible in all cases.<footnote
+    id="whyexpmanip"><para>Unless you&rsquo;re smarter than I am, you
+    don&rsquo;t immediately see why explicit manipulators are necessary.
+    We can tell when quoting and escaping is <emphasis>not</emphasis>
+    appropriate based on type, so doesn&rsquo;t that mean we know when
+    it <emphasis>is</emphasis> appropriate?  Alas, no.  For most data
+    types, it is possible to know, or at least make an awfully good
+    guess, but it&rsquo;s a complete toss-up for C strings, <type>const
+    char*</type>. A C string could be either a literal string of SQL
+    code, or it can be a value used in a query. Since there&rsquo;s no
+    easy way to know and it would damage the library&rsquo;s usability
+    to mandate that C strings only be used for one purpose or the other,
+    the library requires you to be explicit.</para></footnote> Since
+    MySQL++ can&rsquo;t reliably guess when quoting and escaping is
+    appropriate, and the programmer doesn&rsquo;t need
+    to<footnote><para>One hopes the programmer
+    <emphasis>knows</emphasis>.</para></footnote>, MySQL++ makes you
+    tell it.</para>
+  </sect2>
+
+
+  <sect2 id="ssqlsintro" xreflabel="Specialized SQL Structures">
+    <title>Specialized SQL Structures</title>
+
+    <sect3 id="ssqls1">
+      <title>Retrieving data</title>
+
+      <para>The next example introduces one of the most powerful
+      features of MySQL++: Specialized SQL Structures (SSQLS). This is
+      <filename>examples/ssqls1.cpp</filename>:</para>
+
+      <programlisting><xi:include href="ssqls1.txt" parse="text" 
+      xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+      <para>Here is the stock.h header used by that example, and
+      many others:</para>
+
+      <programlisting><xi:include href="stock.txt" parse="text"
+      xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+      <para>This example produces the same output as
+      <filename>simple1.cpp</filename> (see <xref linkend="simple"/>),
+      but it uses higher-level data structures paralleling the
+      database schema instead of MySQL++&rsquo;s lower-level
+      generic data structures. It also uses MySQL++&rsquo;s <xref
+      linkend="exceptions"/> for error handling instead of doing
+      everything inline. For small example programs like these, the
+      overhead of SSQLS and exceptions doesn&rsquo;t pay off very
+      well, but in a real program, they end up working much better
+      than hand-rolled code.</para>
+
+      <para>Notice that we are only pulling a single column from the
+      <varname>stock</varname> table, but we are storing the rows in a
+      <type>std::vector&lt;stock&gt;</type>. It may strike you as
+      inefficient to have five unused fields per record. It&rsquo;s
+      easily remedied by defining a subset SSQLS:</para>
+
+      <programlisting>
+sql_create_1(stock_subset,
+    1, 0,
+    string, item)
+    
+vector&lt;stock_subset&gt; res;
+query.storein(res);
+// ...etc...</programlisting>
+
+      <para>MySQL++ is flexible about populating
+      SSQLSes.<footnote><para>This is a new development in MySQL++
+      v3.0. Programs built against older versions of MySQL++ would
+      crash at almost any mismatch between the database schema and
+      the SSQLS definition. This is a serious problem when the design
+      of the client programs and the database can&rsquo;t be kept
+      in lock-step.</para></footnote> It works much like the Web,
+      a design that&rsquo;s enabled the development of the largest
+      distributed system in the world. Just as a browser ignores
+      tags and attributes it doesn&rsquo;t understand, you can
+      populate an SSQLS from a query result set containing columns
+      that don&rsquo;t exist in the SSQLS. And as a browser uses
+      sensible defaults when the page doesn&rsquo;t give explicit
+      values, you can have an SSQLS with more fields defined than
+      are in the query result set, and these SSQLS fields will get
+      default values. (Zero for numeric types, <type>false</type>
+      for <type>bool</type>, and a type-specific default for anything
+      more complex, like <type>mysqlpp::DateTime</type>.)</para>
+
+      <para>In more concrete terms, the example above is able to
+      populate the <classname>stock</classname> objects using as
+      much information as it has, and leave the remaining fields at
+      their defaults. Conversely, you could also stuff the results
+      of <computeroutput>SELECT * FROM stock</computeroutput> into
+      the <classname>stock_subset</classname> SSQLS declared above;
+      the extra fields would just be ignored.</para>
+      
+      <para>We're trading run-time efficiency for flexibility here,
+      usually the right thing in a distributed system. Since MySQL is
+      a networked database server, many uses of it will qualify as
+      distributed systems. You can't count on being able to update
+      both the server(s) and all the clients at the same time, so
+      you have to make them flexible enough to cope with differences
+      while the changes propagate. As long as the new database schema
+      isn&rsquo;t too grossly different from the old, your programs
+      should continue to run until you get around to updating them
+      to use the new schema.</para>
+
+      <para>There&rsquo;s a danger that this quiet coping behavior
+      may mask problems, but considering that the previous behavior
+      was for the program to crash when the database schema got out
+      of synch with the SSQLS definition, it&rsquo;s likely to be
+      taken as an improvement.</para>
+    </sect3>
+
+
+    <sect3 id="ssqls2">
+      <title>Adding data</title>
+
+      <para>SSQLS can also be used to add data to a table. This is
+      <filename>examples/ssqls2.cpp</filename>:</para>
+
+      <programlisting><xi:include href="ssqls2.txt" parse="text" 
+      xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+      <para>That&rsquo;s all there is to it!</para>
+
+      <para>There is one subtlety: MySQL++ automatically quotes and
+      escapes the data when building SQL queries using SSQLS structures.
+      It&rsquo;s efficient, too: MySQL++ is smart enough to apply
+      quoting and escaping only for those data types that actually
+      require it.</para>
+
+      <para>Because this example modifies the sample database, you
+      may want to run resetdb after running this program.</para>
+    </sect3>
+
+
+    <sect3 id="ssqls3">
+      <title>Modifying data</title>
+
+      <para>It almost as easy to modify data with SSQLS. This is
+      <filename>examples/ssqls3.cpp</filename>:</para>
+
+      <programlisting><xi:include href="ssqls3.txt" parse="text"
+      xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+      <para>Don&rsquo;t forget to run resetdb after running the
+      example.</para>
+    </sect3>
+
+
+    <sect3 id="ssqls4">
+      <title>Less-than-comparable</title>
+
+      <para>SSQLS structures can be sorted and stored in STL associative
+      containers as demonstrated in the next example. This is
+      <filename>examples/ssqls4.cpp</filename>:</para>
+
+      <programlisting><xi:include href="ssqls4.txt" parse="text"
+      xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+      <para>The <methodname>find()</methodname> call works because
+      of the way the SSQLS was declared. It&rsquo;s properly covered
+      elsewhere, but suffice it to say, the "1" in the declaration
+      of <classname>stock</classname> above tells it that only the
+      first field needs to be checked in comparing two SSQLSes. In
+      database terms, this makes it the primary key. Therefore, when
+      searching for a match, our exemplar only had to have its first
+      field populated.</para>
+
+      <para>For more details on the SSQLS feature, see <xref
+      linkend="ssqls"/>.</para>
+    </sect3>
+  </sect2>
+
+
+  <sect2 id="sql_types">
+    <title>C++ Equivalents of SQL Column Types</title>
+
+    <para>The <filename>sql_types.h</filename> header declares typedefs
+    for all MySQL column types. These typedefs all begin with
+    <type>sql_</type> and end with a lowercase version of the standard
+    SQL type name. For instance, the MySQL++ typedef corresponding to
+    <type>TINYINT UNSIGNED</type> is
+    <classname>mysqlpp::sql_tinyint_unsigned</classname>.  You do not
+    have to use these typedefs; in this particular case, you might get
+    away with using something as loose as <type>int</type>.</para>
+
+    <para>The most obivious reason to use these typedefs is clarity.
+    Someone reading code that uses these typedefs can&rsquo;t be
+    confused about what the corresponding SQL type is.</para>
+
+    <para>There&rsquo;s also a correctness aspect to using these
+    typedefs. The definitions of these types have changed over time as
+    new, improved types have become available in MySQL++. For a past
+    example, <type>sql_tinyint</type> used to just be an alias for
+    <type>signed char</type>, but when MySQL++ began treating
+    <type>char</type> as a single-character string instead of an
+    integer, we changed the <type>sql_tinyint</type> typedef to be an
+    alias for <type>mysqlpp::tiny_int&lt;signed char&gt;</type>. Code
+    using the type aliases changed over transparently, while code using
+    what used to be the correct corresponding C++ type usually broke.
+    This is likely to happen again in the future, too. One example that
+    comes to mind is that <type>sql_decimal</type> is currently an alias
+    for <type>double</type>, but SQL&rsquo;s <type>DECIMAL</type> type
+    is a fixed-point data type, while <type>double</type> is
+    floating-point.  Thus, you lose accuracy when converting
+    <type>DECIMAL</type> column data to <type>sql_decimal</type> right
+    now. In the future, we may add a fixed-point data type to MySQL++;
+    if we do, we&rsquo;ll certainly change the tyepdef alias to use it
+    instead of <type>double</type>.</para>
+
+    <para>Most of these typedefs use standard C++ data types, but a few
+    are aliases for a MySQL++ specific type. For instance, the SQL type
+    <classname>DATETIME</classname> is mirrored in MySQL++ by
+    <classname>mysqlpp::DateTime</classname>. For consistency,
+    <filename>sql_types.h</filename> includes a typedef alias for
+    <classname>DateTime</classname> called
+    <classname>mysqlpp::sql_datetime</classname>.</para>
+  </sect2>
+
+
+  <sect2 id="sql-null">
+    <title>Handling SQL Nulls</title>
+
+    <para>There is no equivalent of SQL&rsquo;s null in the standard C++
+    type system.</para>
+
+    <para>The primary distinction is one of type: in SQL, null is a
+    column attribute, which affects whether that column can hold a SQL
+    null. Just like the <symbol>const</symbol> keyword in the C++ type
+    system, this effectively doubles the number of SQL data types. To
+    emulate this, MySQL++ provides the <ulink type="classref"
+    url="null">Null</ulink> template to allow the creation of distinct
+    &ldquo;nullable&rdquo; versions of existing C++ types. So for
+    example, if you have a <type>TINYINT UNSIGNED</type> column that can
+    have nulls, the proper declaration for MySQL++ would be:</para>
+
+    <programlisting>
+mysqlpp::Null&lt;mysqlpp::sql_tinyint_unsigned&gt; myfield;</programlisting>
+
+    <para>Template instantiations are first-class types in the C++
+    language, on par with any other type. You can use
+    <classname>Null</classname> template instantiations anywhere
+    you&rsquo;d use the plain version of that type. (You can see a
+    complete list of <classname>Null</classname> template instantiations
+    for all column types that MySQL understands at the top of
+    <filename>lib/type_info.cpp</filename>.)</para>
+
+    <para>There&rsquo;s a secondary distinction between SQL null and
+    anything available in the standard C++ type system: SQL null is a
+    distinct value, equal to nothing else. We can&rsquo;t use
+    C++&rsquo;s <symbol>NULL</symbol> for this because it is ambiguous,
+    being equal to 0 in integer context. MySQL++ provides the global
+    <varname>null</varname> object, which you can assign to a
+    <classname>Null</classname> template instance to make it equal to
+    SQL null:</para>
+
+    <programlisting>
+myfield = mysqlpp::null;</programlisting>
+
+    <para>By default, MySQL++ enforces the uniqueness of SQL null at
+    compile time. If you try to convert a SQL null to any other data
+    type, the compiler will emit an error message saying something
+    about <type>CannotConvertNullToAnyOtherDataType</type>. It&rsquo;s
+    safe to insert a SQL null into a C++ stream, though: you get
+    &ldquo;(NULL)&rdquo;.</para>
+
+    <para>If you don&rsquo;t like this behavior, you can change it
+    by passing a different value for the second parameter to template
+    <classname>Null</classname>. By default, this parameter is <ulink
+    type="structref" url="NullIsNull"/>, meaning that we should
+    enforce the uniqueness of SQL null. To relax this distinction,
+    you can instantiate the <classname>Null</classname> template with a
+    different behavior type: <ulink type="structref" url="NullIsZero"/>
+    or <ulink type="structref" url="NullIsBlank"/>. Consider this
+    code:</para>
+
+    <programlisting>
+mysqlpp::Null&lt;unsigned char, mysqlpp::NullIsZero&gt; myfield(mysqlpp::null);
+cout &lt;&lt; myfield &lt;&lt; endl;
+cout &lt;&lt; int(myfield) &lt;&lt; endl;</programlisting>
+
+    <para>This will print &ldquo;0&rdquo; twice. If you had used the
+    default for the second <classname>Null</classname> template
+    parameter, the first output statement would have printed
+    &ldquo;(NULL)&rdquo;, and the second wouldn&rsquo;t even
+    compile.</para>
+  </sect2>
+
+
+  <sect2 id="Transaction">
+    <title>Using Transactions</title>
+
+    <para>The <ulink type="classref" url="Transaction"/> class makes it
+    easier to use SQL transactions in an exception-safe manner. Normally
+    you create the <classname>Transaction</classname> object on the
+    stack before you issue the queries in your transaction set. Then,
+    when all the queries in the transaction set have been issued, you
+    call <function>Transaction::commit()</function>, which commits the
+    transaction set. If the <classname>Transaction</classname> object
+    goes out of scope before you call <function>commit()</function>, the
+    transaction set is rolled back. This ensures that if some code
+    throws an exception after the transaction is started but before it
+    is committed, the transaction isn&rsquo;t left unresolved.</para>
+
+    <para><filename>examples/transaction.cpp</filename> illustrates
+    this:</para>
+
+    <programlisting><xi:include href="transaction.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>One of the downsides of transactions is that the locking it
+    requires in the database server is prone to deadlocks. The classic
+    case where this happens is when two programs both want access to the
+    same two rows within a single transaction each, but they modify them
+    in opposite orders. If the timing is such that the programs
+    interleave their lock acquisitions, the two come to an impasse:
+    neither can get access to the other row they want to modify until
+    the other program commits its transaction and thus release the row
+    locks, but neither can finish the transaction because they&rsquo;re
+    waiting on row locks the database server is holding on behalf of the
+    other program.</para>
+
+    <para>The MySQL server is smart enough to detect this condition, but
+    the best it can do is abort the second transaction. This breaks the
+    impasse, allowing the first program to complete its
+    transaction.</para>
+
+    <para>The second program now has to deal with the fact that its
+    transaction just got aborted. There&rsquo;s a subtlety in detecting
+    this situation when using MySQL++. By default, MySQL++ signals
+    errors like these with exceptions. In the exception handler, you
+    might expect to get <constant>ER_LOCK_DEADLOCK</constant> from
+    <methodname>Query::errnum()</methodname> (or
+    <methodname>Connection::errnum()</methodname>, same thing), but what
+    you&rsquo;ll almost certainly get instead is 0, meaning &ldquo;no
+    error.&rdquo; Why? It&rsquo;s because you&rsquo;re probably using a
+    <classname>Transaction</classname> object to get automatic
+    roll-backs in the face of exceptions. In this case, the roll-back
+    happens before your exception handler is called by issuing a
+    <command>ROLLBACK</command> query to the database server. Thus,
+    <methodname>Query::errnum()</methodname> returns the error code
+    associated with this roll-back query, not the deadlocked transaction
+    that caused the exception.</para>
+
+    <para>To avoid this problem, a few of the exception objects as of
+    MySQL++ v3.0 include this last error number in the exception object
+    itself. It&rsquo;s populated at the point of the exception, so it
+    can differ from the value you would get from
+    <methodname>Query::errnum()</methodname> later on when the exception
+    handler runs.</para>
+
+    <para>The example <filename>examples/deadlock.cpp</filename>
+    demonstrates the problem:</para>
+
+    <programlisting><xi:include href="deadlock.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>This example works a little differently than the others.  You
+    run one copy of the example, then when it pauses waiting for you to
+    press <keycap>Enter</keycap>, you run another copy.  Then, depending
+    on which one you press <keycap>Enter</keycap> in, one of the two
+    will abort with the deadlock exception. You can see from the error
+    message you get that it matters which method you call to get the
+    error number. What you do about it is up to you as it depends on
+    your program&rsquo;s design and system architecture.</para>
+  </sect2>
+
+
+  <sect2 id="querytypes">
+    <title>Which Query Type to Use?</title>
+
+    <para>There are three major ways to execute a query in MySQL++:
+    <methodname>Query::execute()</methodname>,
+    <methodname>Query::store()</methodname>, and
+    <methodname>Query::use()</methodname>. Which should you use, and
+    why?</para>
+
+    <para><methodname>execute()</methodname> is for queries that do not
+    return data <emphasis>per se</emphasis>. For instance,
+    <command>CREATE INDEX</command>. You do get back some information
+    from the MySQL server, which <methodname>execute()</methodname>
+    returns to its caller in a <ulink type="classref"
+    url="SimpleResult"/> object. In addition to the obvious &mdash; a
+    flag stating whether the query succeeded or not &mdash; this object
+    also contains things like the number of rows that the query
+    affected. If you only need the success status, it&rsquo;s a little
+    more efficient to call <methodname>Query::exec()</methodname>
+    instead, as it simply returns <type>bool</type>.</para>
+
+    <para>If your query does pull data from the database, the simplest
+    option is <methodname>store()</methodname>. (All of the examples up
+    to this point have used this method.)  This returns a <ulink
+    type="classref" url="StoreQueryResult"/> object, which contains the
+    entire result set. It&rsquo;s especially convenient because
+    <classname>StoreQueryResult</classname> derives from
+    <classname>std::vector&lt;mysqlpp::Row&gt;</classname>, so it opens
+    the whole panoply of STL operations for accessing the rows in the
+    result set. Access rows randomly with subscript notation, iterate
+    forwards and backwards over the result set, run STL algorithms on
+    the set...it all works naturally.</para>
+
+    <para>If you like the idea of storing your results in an STL
+    container but don&rsquo;t want to use
+    <classname>std::vector</classname>, you can call
+    <methodname>Query::storein()</methodname> instead. It lets you store
+    the results in any standard STL container (yes, both sequential and
+    set-associative types) instead of using
+    <classname>StoreQueryResult</classname>. You do miss out on some of
+    the additional database information held by
+    <classname>StoreQueryResult</classname>&rsquo;s other base class,
+    <ulink type="classref" url="ResultBase"/>, however.</para>
+
+    <para><methodname>store*()</methodname> queries are convenient, but
+    the cost of keeping the entire result set in main memory can
+    sometimes be too high. It can be surprisingly costly, in fact. A
+    MySQL database server stores data compactly on disk, but it returns
+    query data to the client in a textual form. This results in a kind
+    of data bloat that affects numeric and BLOB types the most. MySQL++
+    and the underlying C API library also have their own memory
+    overheads in addition to this. So, if you happen to know that the
+    database server stores every record of a particular table in 1 KB,
+    pulling a million records from that table could easily take several
+    GB of memory with a <methodname>store()</methodname> query,
+    depending on what&rsquo;s actually stored in that table.</para>
+
+    <para>For these large result sets, the superior option is a
+    <methodname>use()</methodname> query. This returns a <ulink
+    type="classref" url="UseQueryResult"/> object, which is similar to
+    <classname>StoreQueryResult</classname>, but without all of the
+    random-access features. This is because a &ldquo;use&rdquo; query
+    tells the database server to send the results back one row at a
+    time, to be processed linearly. It&rsquo;s analogous to a C++
+    stream&rsquo;s input iterator, as opposed to a random-access
+    iterator that a container like vector offers. By accepting this
+    limitation, you can process arbitrarily large result sets. This
+    technique is demonstrated in
+    <filename>examples/simple3.cpp</filename>:</para>
+
+    <programlisting><xi:include href="simple3.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>This example does the same thing as
+    <filename>simple2</filename>, only with a &ldquo;use&rdquo; query
+    instead of a &ldquo;store&rdquo; query.</para>
+
+    <para>Valuable as <methodname>use()</methodname> queries are, they
+    should not be the first resort in solving problems of excessive
+    memory use. It&rsquo;s better if you can find a way to simply not
+    pull as much data from the database in the first place. Maybe
+    you&rsquo;re saying <command>SELECT *</command> even though you
+    don&rsquo;t immedidately need all the columns from the table. Or,
+    maybe you&rsquo;re filtering the result set with C++ code after you
+    get it from the database server. If you can do that filtering with a
+    more restrictive <command>WHERE</command> clause on the
+    <command>SELECT</command>, it&rsquo;ll not only save memory,
+    it&rsquo;ll save bandwidth between the database server and client,
+    and can even save CPU time. If the filtering criteria can&rsquo;t be
+    expressed in a <command>WHERE</command> clause, however, read on to
+    the next section.</para>
+  </sect2>
+
+
+  <sect2 id="store_if">
+    <title>Conditional Result Row Handling</title>
+
+    <para>Sometimes you must pull more data from the database server
+    than you actually need and filter it in memory. SQL&rsquo;s
+    <command>WHERE</command> clause is powerful, but not as powerful as
+    C++. Instead of storing the full result set and then picking over it
+    to find the rows you want to keep, use
+    <methodname>Query::store_if()</methodname>. This is
+    <filename>examples/store_if.cpp</filename>:</para>
+
+    <programlisting><xi:include href="store_if.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>I doubt anyone really needs to select rows from a table that
+    have a prime number in a given field. This example is meant to be
+    just barely more complex than SQL can manage, to avoid obscuring the
+    point. That point being, the
+    <methodname>Query::store_if()</methodname> call here gives you a
+    container full of results meeting a criterion that you probably
+    can&rsquo;t express in SQL. You will no doubt have much more useful
+    criteria in your own programs.</para>
+
+    <para>If you need a more complex query than the one
+    <methodname>store_if()</methodname> knows how to build when given an
+    SSQLS examplar, there are two overloads that let you use your own
+    query string. One overload takes the query string directly, and the
+    other uses the query string built with
+    <classname>Query</classname>&rsquo;s stream interface.</para>
+  </sect2>
+
+
+  <sect2 id="for_each">
+    <title>Executing Code for Each Row In a Result Set</title>
+
+    <para>SQL is more than just a database query language. Modern
+    database engines can actually do some calculations on the data on
+    the server side. But, this isn&rsquo;t always the best way to get
+    something done. When you need to mix code and a query,
+    MySQL++&rsquo;s <methodname>Query::for_each()</methodname> facility
+    might be just what you need. This is
+    <filename>examples/for_each.cpp</filename>:</para>
+
+    <programlisting><xi:include href="for_each.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>You only need to read the <function>main()</function> function
+    to get a good idea of what the program does. The key line of code
+    passes an SSQLS examplar and a functor to
+    <methodname>Query::for_each()</methodname>.
+    <methodname>for_each()</methodname> uses the SSQLS instance to build
+    a <computeroutput>select * from TABLE</computeroutput> query,
+    <computeroutput>stock</computeroutput> in this case. It runs that
+    query internally, calling <classname>gather_stock_stats</classname>
+    on each row. This is a pretty contrived example; you could actually
+    do this in SQL, but we&rsquo;re trying to prevent the complexity of
+    the code from getting in the way of the demonstration here.</para>
+
+    <para>Just as with <methodname>store_if()</methodname>, described
+    above, there are two other overloads for
+    <methodname>for_each()</methodname> that let you use your own query
+    string.</para>
+  </sect2>
+
+
+  <sect2 id="connopts" xreflabel="connection options">
+    <title>Connection Options</title>
+
+    <para>MySQL has a large number of options that control how it makes
+    the connection to the database server, and how that connection
+    behaves. The defaults are sufficient for most programs, so only one
+    of the MySQL++ example programs make any connection option changes.
+    Here is <filename>examples/multiquery.cpp</filename>:</para>
+
+    <programlisting><xi:include href="multiquery.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+    <para>This is a fairly complex example demonstrating the multi-query
+    and stored procedure features in newer versions of MySQL. Because
+    these are new features, and they change the communication between
+    the client and server, you have to enable these features in a
+    connection option. The key line is right up at the top of
+    <function>main()</function>, where it creates a <ulink
+    type="classref" url="MultiStatementsOption"/> object and passes it
+    to <methodname>Connection::set_option()</methodname>. That method
+    will take a pointer to any derivative of <ulink type="classref"
+    url="Option"/>: you just create such an object on the heap and pass
+    it in, which gives <classname>Connection</classname> the data values
+    it needs to set the option. You don&rsquo;t need to worry about
+    releasing the memory used by the <classname>Option</classname>
+    objects; it&rsquo;s done automatically.</para>
+
+    <para>The only tricky thing about setting options is that only a few
+    of them can be set after the connection is up. Most need to be set
+    just as shown in the example above: create an unconnected
+    <classname>Connection</classname> object, set your connection
+    options, and only then establish the connection. The option setting
+    mechanism takes care of applying the options at the correct time in
+    the connection establishment sequence.</para>
+
+    <para>If you&rsquo;re familiar with setting connection options in
+    the MySQL C API, you&rsquo;ll have to get your head around the fact
+    that MySQL++&rsquo;s connection option mechanism is a much simpler,
+    higher-level design that doesn&rsquo;t resemble the C API in any
+    way. The C API has something like half a dozen different mechanisms
+    for setting options that control the connection. The flexibility of
+    the C++ type system allows us to wrap all of these up into a single
+    high-level mechanism while actually getting greater type safety than
+    the C API allows.</para>
+  </sect2>
+
+
+  <sect2 id="fieldinf">
+    <title>Getting Field Meta-Information</title>
+
+    <para>The following example demonstrates how to get information
+    about the fields in a result set, such as the name of the field and
+    the SQL type. This is
+    <filename>examples/fieldinf.cpp</filename>:</para>
+
+    <programlisting><xi:include href="fieldinf.txt" parse="text"
+    xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+  </sect2>
+
+
+  <sect2 id="string-types">
+    <title>MySQL++&rsquo;s Special String Types</title>
+
+    <para>MySQL++ has two classes that work like
+    <classname>std::string</classname> to some degree: <ulink
+    type="classref" url="String"/> and <ulink type="classref"
+    url="SQLTypeAdapter"/>. These classes exist to provide functionality
+    that <classname>std::string</classname> doesn&rsquo;t provide, but
+    they are neither derivatives of nor complete supersets of
+    <classname>std::string</classname>.  As a result, end-user code
+    generally doesn&rsquo;t deal with these classes directly, because
+    <classname>std::string</classname> is a better general-purpose
+    string type. In fact, MySQL++ itself uses
+    <classname>std::string</classname> most of the time, too. But, the
+    places these specialized stringish types do get used are so
+    important to the way MySQL++ works that it&rsquo;s well worth taking
+    the time to understand them.</para>
+
+
+    <sect3 id="SQLTypeAdapter">
+      <title>SQLTypeAdapter</title>
+
+      <para>The simpler of the two is
+      <classname>SQLTypeAdapter</classname>, or
+      <classname>STA</classname> for short.<footnote><para>In version 2
+      of MySQL++ and earlier, <classname>SQLTypeAdapter</classname> was
+      called <classname>SQLString</classname>, but it was confusing
+      because its name and the fact that it derived from
+      <classname>std::string</classname> suggested that it was a
+      general-purpose string type. MySQL++ even used it this way in a
+      few places internally. In v3, we made it a simple base class and
+      renamed it to reflect its proper limited
+      function.</para></footnote></para>
+
+      <para>As its name suggests, its only purpose is to adapt other
+      data types to be used with SQL. It has a whole bunch of conversion
+      constructors, one for all data types we expect to be used with
+      MySQL++ for values in queries. SQL queries are strings, so
+      constructors that take stringish types just make a copy of that
+      string, and all the others &ldquo;stringize&rdquo; the value in
+      the format needed by
+      SQL.<footnote><para><classname>SQLTypeAdapter</classname>
+      doesn&rsquo;t do <xref linkend="qescape"/> itself. That happens
+      elsewhere, right at the point that the <classname>STA</classname>
+      gets used to build a query.</para></footnote> The conversion
+      constructors preserve type information, so this stringization
+      process doesn&rsquo;t throw away any essential information.</para>
+
+      <para><classname>STA</classname> is used anywhere MySQL++ needs to
+      be able to accept any of several data types for use in a SQL
+      query. Major users are <classname>Query</classname>&rsquo;s
+      template query mechanism and the <classname>Query</classname>
+      stream quoting and escaping mechanism. You care about
+      <classname>STA</classname> because any time you pass a data value
+      to MySQL++ to be used in building a SQL query, it goes through
+      <classname>STA</classname>. <classname>STA</classname> is one of
+      the key pieces in MySQL++ that makes it easy to generate
+      syntactically-correct SQL queries.</para>
+    </sect3>
+
+
+    <sect3 id="String">
+      <title>String</title>
+
+      <para>If MySQL++ can be said to have its own generic string type,
+      it&rsquo;s <classname>String</classname>, but it&rsquo;s not
+      really functional enough for general use. It&rsquo;s possible that
+      in future versions of MySQL++ we&rsquo;ll expand its interface to
+      include everything <classname>std::string</classname> does, so
+      that&rsquo;s why it&rsquo;s called that.<footnote><para>If you
+      used MySQL++ before v3, <classname>String</classname> used to be
+      called <classname>ColData</classname>. It was renamed because
+      starting in v2.3, we began using it for holding more than just
+      column data. I considered renaming it
+      <classname>SQLString</classname> instead, but that would have
+      confused old MySQL++ users to no end. Instead, I followed the
+      example of <classname>Set</classname>, MySQL++&rsquo;s specialized
+      <classname>std::set</classname> variant.</para></footnote></para>
+
+      <para>The key thing <classname>String</classname> provides over
+      <classname>std::string</classname> is conversion of strings in SQL
+      value formats to their native C++ data types. For example, if you
+      initialize it with the string &ldquo;2007-11-19&rdquo;, you can
+      assign the <classname>String</classname> to a <ulink
+      type="structref" url="Date">Date</ulink>, not because
+      <classname>Date</classname> knows how to initialize itself from
+      <classname>String</classname>, but the reverse:
+      <classname>String</classname> has a bunch of implicit conversion
+      operators defined for it, so you can use it in any type context
+      that makes sense in your application.</para>
+
+      <para>Because <methodname>Row::operator[]</methodname> returns
+      <classname>String</classname>, you can say things like
+      this:</para>
+
+      <programlisting>int x = row["x"];</programlisting>
+
+      <para>In a very real sense, <classname>String</classname> is the
+      inverse of <classname>STA</classname>:
+      <classname>String</classname> converts SQL value strings to C++
+      data types, and <classname>STA</classname> converts C++ data types
+      to SQL value strings.<footnote><para>During the development of
+      MySQL++ v3.0, I tried merging
+      <classname>SQLTypeAdapter</classname> and
+      <classname>String</classname> into a single class to take
+      advantage of this. The resulting class gave the C++ compiler the
+      freedom to tie itself up in knots, because it was then allowed to
+      convert almost any data type to almost any other. You&rsquo;d get
+      a tangle of ambiguous data type conversion errors from the most
+      innocent code.</para></footnote></para>
+
+      <para><classname>String</classname> has two main uses.</para>
+
+      <para>By far the most common use is as the field value type of
+      <classname>Row</classname>, as exemplified above. It&rsquo;s not
+      just the return type of <methodname>Row::operator[]</methodname>,
+      though: it&rsquo;s actually the value type used within
+      <classname>Row</classname>&rsquo;s internal array. As a result,
+      any time MySQL++ pulls data from the database, it goes through
+      <classname>String</classname> when converting it from the string
+      form used in SQL result sets to the C++ data type you actually
+      want the data in. It&rsquo;s the core of the structure population
+      mechanism in <xref linkend="ssqlsintro"/>, for example.</para>
+
+      <para>Because <classname>String</classname> is the last pristine
+      form of data in a result set before it gets out of MySQL++&rsquo;s
+      internals where end-user code can see it, MySQL++&rsquo;s
+      <type>sql_blob</type> and related <type>typedef</type>s are
+      aliases for <classname>String</classname>. Using anything else
+      would require copies; while the whole &ldquo;networked database
+      server&rdquo; thing means most of MySQL++ can be quite inefficient
+      and still not affect benchmark results meaningfully, BLOBs tend to
+      be big, so making unnecessary copies can really make a difference.
+      Which brings us to...</para>
+    </sect3>
+
+
+    <sect3 id="string-refcount">
+      <title>Reference Counting</title>
+
+      <para>To avoid unnecessary buffer copies, both
+      <classname>STA</classname> and <classname>String</classname> are
+      implemented in terms of a reference-counted copy-on-write buffer
+      scheme. Both classes share the same underlying mechanism, and so
+      are interoperable. This means that if you construct one of these
+      objects from another, it doesn&rsquo;t actually copy the string
+      data, it only copies a pointer to the data buffer, and increments
+      its reference count. If the object has new data assigned to it or
+      it&rsquo;s otherwise modified, it decrements its reference count
+      and creates its own copy of the buffer. This has a lot of
+      practical import, such as the fact that
+      <methodname>Row::operator[]</methodname> can return
+      <classname>String</classname> by value, and it&rsquo;s still
+      efficient.</para>
+    </sect3>
+  </sect2>
+
+
+  <sect2 id="blob">
+    <title>Dealing with Binary Data</title>
+
+    <para>The tricky part about dealing with binary data in MySQL++ is
+    to ensure that you don&rsquo;t ever treat the data as a C string,
+    which is really easy to do accidentally. C strings treat zero bytes
+    as special end-of-string characters, but they&rsquo;re not special
+    at all in binary data. Recent releases of MySQL++ do a better job of
+    letting you keep data in forms that don&rsquo;t have this problem,
+    but it&rsquo;s still possible to do it incorrectly. These examples
+    demonstrate correct techniques.</para>
+
+
+    <sect3 id="blob-save">
+      <title>Loading a binary file into a BLOB column</title>
+
+      <para>This example shows how to insert binary data into a MySQL
+      table&rsquo;s BLOB column with MySQL++, and also how to get the
+      value of the auto-increment column from the previous insert. (This
+      MySQL feature is usually used to create unique IDs for rows as
+      they&rsquo;re inserted.) The program requires one command line
+      parameter over that required by the other examples you&rsquo;ve
+      seen so far, the path to a JPEG file. This is
+      <filename>examples/load_jpeg.cpp</filename>:</para>
+
+      <programlisting><xi:include href="load_jpeg.txt" parse="text"
+      xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+      <para>Notice that we used the <type>escape</type> manipulator when
+      building the INSERT query above. This is because we&rsquo;re not
+      using one of the MySQL++ types that does automatic escaping and
+      quoting.</para>
+    </sect3>
+
+
+    <sect3 id="blob-retreive">
+      <title>Serving images from BLOB column via CGI</title>
+
+      <para>This example is also a very short one, considering the
+      function that it performs. It retreives data loaded by
+      <filename>load_jpeg</filename> and prints it out in the form a web
+      server can accept for a CGI call. This is
+      <filename>examples/cgi_jpeg.cpp</filename>:</para>
+
+      <programlisting><xi:include href="cgi_jpeg.txt" parse="text"
+      xmlns:xi="http://www.w3.org/2001/XInclude"/></programlisting>
+
+      <para>You install this in a web server&rsquo;s CGI program
+      directory, then call it with a URL like
+      <uri>http://my.server.com/cgi-bin/cgi_jpeg?id=1</uri>.  That
+      retrieves the JPEG with ID 1 from the table and returns it to the
+      web server, which will send it on to the browser.</para>
+    </sect3>
+  </sect2>
+
+
+  <sect2 id="concurrentqueries">
+    <title>Concurrent Queries on a Connection</title>
+
+    <para>An important limitation of the MySQL C API library &mdash;
+    which MySQL++ is built atop, so it shares this limitation &mdash; is
+    that you can&rsquo;t have two concurrent queries running on a single
+    connection. If you try, you get an obscure error message about
+    &ldquo;Commands out of sync&rdquo; from the underlying C API
+    library. (You get it in a MySQL++ exception unless you have
+    exceptions disabled, in which case you get a failure code and
+    <methodname>Connection::error()</methodname> returns this
+    message.)</para>
+
+    <para>The easiest way to cause this error is in a multithreaded
+    program where you have a single <ulink type="classref"
+    url="Connection"/> object, but allow multiple threads to issue
+    queries on it. Unless you put in a lot of work to synchronize
+    access, this is almost guaranteed to fail.</para>
+
+    <para>If you give each thread that issues queries has its own
+    <classname>Connection</classname> object, you can still run into
+    trouble if you pass the data you get from queries around to other
+    threads. What can happen is that one of these child objects
+    indirectly calls back to the <classname>Connection</classname> at a
+    time where it&rsquo;s involved with another query. (There are other
+    ways to run into trouble when sharing MySQL++ data structures among
+    threads, but the whole topic is complex enough to deserve its own
+    chapter, <xref linkend="threads"/>.)</para>
+
+    <para>It&rsquo;s possible to run into this problem in a
+    single-threaded program as well. As discussed above (<xref
+    linkend="querytypes"/>), one of the options MySQL offers for
+    executing a query lets you issue the query, then consume the rows
+    one at a time, on demand: it&rsquo;s the &ldquo;use&rdquo; query. If
+    you don&rsquo;t consume all rows from a query before you issue
+    another on that connection, you are effectively trying to have
+    multiple concurrent queries on a single connection, and you end up
+    with the same problem. The simplest recipie for disaster is:</para>
+
+    <programlisting>
+UseQueryResult r1 = query.use("select garbage from plink where foobie='tamagotchi'");
+UseQueryResult r2 = query.use("select blah from bonk where bletch='smurf'");</programlisting>
+
+    <para>The second <methodname>use()</methodname> call fails because
+    the first result set hasn&rsquo;t been consumed yet.</para>
+  </sect2>
+</sect1>

ADDED   doc/userman/unicode.dbx
Index: doc/userman/unicode.dbx
==================================================================
--- /dev/null
+++ doc/userman/unicode.dbx
@@ -0,0 +1,189 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<sect1 id="unicode" xreflabel="Using Unicode with MySQL++">
+  <title>Using Unicode with MySQL++</title>
+
+  <sect2 id="unicode-history">
+    <title>A Short History of Unicode</title>
+    <subtitle>...with a focus on relevance to MySQL++</subtitle>
+
+    <para>In the old days, computer operating systems only dealt with
+    8-bit character sets. That only allows for 256 possible characters,
+    but the modern Western languages have more characters combined than
+    that alone. Add in all the other languages of the world plus the
+    various symbols people use in writing, and you have a real
+    mess!</para>
+
+    <para>Since no standards body held sway over things like
+    international character encoding in the early days of computing,
+    many different character sets were invented. These character sets
+    weren&rsquo;t even standardized between operating systems, so heaven
+    help you if you needed to move localized Greek text on a DOS box to
+    a Russian Macintosh! The only way we got any international
+    communication done at all was to build standards on top of the
+    common 7-bit ASCII subset.  Either people used approximations like a
+    plain &ldquo;c&rdquo; instead of the French &ldquo;&ccedil;&rdquo;,
+    or they invented things like HTML entities
+    (&ldquo;&amp;ccedil;&rdquo; in this case) to encode these additional
+    characters using only 7-bit ASCII.</para>
+
+    <para>Unicode solves this problem. It encodes every character used
+    for writing in the world, using up to 4 bytes per character. The
+    subset covering the most economically valuable cases takes two bytes
+    per character, so most Unicode-aware programs deal in 2-byte
+    characters, for efficiency.</para>
+
+    <para>Unfortunately, Unicode was invented about two decades too late
+    for Unix and C. Those decades of legacy created an immense inertia
+    preventing a widespread move away from 8-bit characters. MySQL and
+    C++ come out of these older traditions, and so they share the same
+    practical limitations. MySQL++ doesn&rsquo;t have a reason to do
+    anything more than just pass data along unchanged, so you still need
+    to be aware of these underlying issues.</para>
+
+    <para>During the development of the <ulink
+    url="http://en.wikipedia.org/wiki/Plan_9_from_Bell_Labs">Plan
+    9</ulink> operating system (a kind of successor to Unix) Ken
+    Thompson <ulink
+    url="http://www.cl.cam.ac.uk/~mgk25/ucs/utf-8-history.txt">invented</ulink>
+    the <ulink url="http://en.wikipedia.org/wiki/UTF-8">UTF-8
+    encoding</ulink>. UTF-8 is a superset of 7-bit ASCII and is
+    compatible with C strings, since it doesn&rsquo;t use 0 bytes
+    anywhere as multi-byte Unicode encodings do. As a result, many
+    programs that deal in text will cope with UTF-8 data even though
+    they have no explicit support for UTF-8. (Follow the last link above
+    to see how the design of UTF-8 allows this.) Thus, when explicit
+    support for Unicode was added in MySQL v4.1, they chose to make
+    UTF-8 the native encoding, to preserve backward compatibility with
+    programs that had no Unicode support.</para>
+  </sect2>
+
+
+  <sect2 id="unicode-unix">
+    <title>Unicode on Unixy Systems</title>
+
+    <para>Linux and Unix have system-wide UTF-8 support these days. If
+    your operating system is of 2001 or newer vintage, it probably has
+    such support.</para>
+
+    <para>On such a system, the terminal I/O code understands UTF-8
+    encoded data, so your program doesn&rsquo;t require any special code
+    to correctly display a UTF-8 string. If you aren&rsquo;t sure
+    whether your system supports UTF-8 natively, just run the
+    <filename>simple1</filename> example: if the first item has two
+    high-ASCII characters in place of the &ldquo;&uuml;&rdquo; in
+    &ldquo;N&uuml;rnberger Brats&rdquo;, you know it&rsquo;s not
+    handling UTF-8.</para>
+
+    <para>If your Unix doesn&rsquo;t support UTF-8 natively, it likely
+    doesn&rsquo;t support any form of Unicode at all, for the historical
+    reasons I gave above. Therefore, you will have to convert the UTF-8
+    data to the local 8-bit character set. The standard Unix function
+    <function>iconv()</function> can help here. If your system
+    doesn&rsquo;t have the <function>iconv()</function> facility, there
+    is <ulink url="http://www.gnu.org/software/libiconv/">a free
+    implementation</ulink> available from the GNU Project. Another
+    library you might check out is IBM&rsquo;s <ulink
+    url="http://icu.sourceforge.net/">ICU</ulink>. This is rather
+    heavy-weight, so if you just need basic conversions,
+    <function>iconv()</function> should suffice.</para>
+  </sect2>
+
+
+  <sect2 id="unicode-windows">
+    <title>Unicode on Windows</title>
+
+    <para>Each Windows API function that takes a string actually comes
+    in two versions. One version supports only 1-byte &ldquo;ANSI&rdquo;
+    characters (a superset of ASCII), so they end in 'A'. Windows also
+    supports the 2-byte subset of Unicode called <ulink
+    url="http://en.wikipedia.org/wiki/UCS-2">UCS-2</ulink>.  Some call
+    these &ldquo;wide&rdquo; characters, so the other set of functions
+    end in 'W'. The <function><ulink
+    url="http://msdn.microsoft.com/library/en-us/winui/winui/windowsuserinterface/windowing/dialogboxes/dialogboxreference/dialogboxfunctions/messagebox.asp">MessageBox</ulink>()</function>
+    API, for instance, is actually a macro, not a real function. If you
+    define the <symbol>UNICODE</symbol> macro when building your
+    program, the <function>MessageBox()</function> macro evaluates to
+    <function>MessageBoxW()</function>; otherwise, to
+    <function>MessageBoxA()</function>.</para>
+
+    <para>Since MySQL uses the UTF-8 Unicode encoding and Windows uses
+    UCS-2, you must convert data when passing text between MySQL++ and
+    the Windows API. Since there&rsquo;s no point in trying for
+    portability &mdash; no other OS I&rsquo;m aware of uses UCS-2
+    &mdash; you might as well use platform-specific functions to do this
+    translation. Since version 2.2.2, MySQL++ ships with two Visual C++
+    specific examples showing how to do this in a GUI program.  (In
+    earlier versions of MySQL++, we did Unicode conversion in the
+    console mode programs, but this was unrealistic.)</para>
+
+    <para>How you handle Unicode data depends on whether you&rsquo;re
+    using the native Windows API, or the newer .NET API. First, the
+    native case:</para>
+
+    <programlisting>
+// Convert a C string in UTF-8 format to UCS-2 format.
+void ToUCS2(LPTSTR pcOut, int nOutLen, const char* kpcIn)
+{
+  MultiByteToWideChar(CP_UTF8, 0, kpcIn, -1, pcOut, nOutLen);
+}
+
+// Convert a UCS-2 string to C string in UTF-8 format.
+void ToUTF8(char* pcOut, int nOutLen, LPCWSTR kpcIn)
+{
+  WideCharToMultiByte(CP_UTF8, 0, kpcIn, -1, pcOut, nOutLen, 0, 0);
+}</programlisting>
+
+    <para>These functions leave out some important error checking, so
+    see <filename>examples/vstudio/mfc/mfc_dlg.cpp</filename> for the
+    complete version.</para>
+
+    <para>If you&rsquo;re building a .NET application (such as, perhaps,
+    because you&rsquo;re using Windows Forms), it&rsquo;s better to use
+    the .NET libraries for this:</para>
+
+    <programlisting>
+// Convert a C string in UTF-8 format to a .NET String in UCS-2 format.
+String^ ToUCS2(const char* utf8)
+{
+  return gcnew String(utf8, 0, strlen(utf8), System::Text::Encoding::UTF8);
+}
+
+// Convert a .NET String in UCS-2 format to a C string in UTF-8 format.
+System::Void ToUTF8(char* pcOut, int nOutLen, String^ sIn)
+{
+  array&lt;Byte&gt;^ bytes = System::Text::Encoding::UTF8->GetBytes(sIn);
+  nOutLen = Math::Min(nOutLen - 1, bytes->Length);
+  System::Runtime::InteropServices::Marshal::Copy(bytes, 0,
+    IntPtr(pcOut), nOutLen);
+  pcOut[nOutLen] = '\0';
+}</programlisting>
+
+    <para>Unlike the native API versions, these examples are complete,
+    since the .NET platform handles a lot of things behind the scenes
+    for us. We don&rsquo;t need any error-checking code for such simple
+    routines.</para>
+
+    <para>All of this assumes you&rsquo;re using Windows NT or one of
+    its direct descendants: Windows 2000, Windows XP, Windows Vista, or
+    any &ldquo;Server&rdquo; variant of Windows. Windows 95 and its
+    descendants (98, ME, and CE) do not support UCS-2. They still have
+    the 'W' APIs for compatibility, but they just smash the data down to
+    8-bit and call the 'A' version for you.</para>
+  </sect2>
+
+
+  <sect2 id="unicode-refs">
+    <title>For More Information</title>
+      <para>The <ulink url="http://www.unicode.org/faq/">Unicode
+      FAQs</ulink> page has copious information on this complex
+      topic.</para>
+
+      <para>When it comes to Unix and UTF-8 specific items, the <ulink
+      url="http://www.cl.cam.ac.uk/~mgk25/unicode.html">UTF-8 and
+      Unicode FAQ for Unix/Linux</ulink> is a quicker way to find basic
+      information.</para>
+    </sect2>
+</sect1>

ADDED   doc/userman/userman.dbx
Index: doc/userman/userman.dbx
==================================================================
--- /dev/null
+++ doc/userman/userman.dbx
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<article>
+	<articleinfo>
+		<title>MySQL++ v3.0.3 User Manual</title>
+
+		<authorgroup>
+			<author>
+				<firstname>Kevin</firstname>
+				<surname>Atkinson</surname>
+			</author>
+
+			<author>
+				<firstname>Sinisa</firstname>
+				<surname>Milivojevic</surname>
+			</author>
+
+			<author>
+				<firstname>Monty</firstname>
+				<surname>Widenius</surname>
+			</author>
+
+			<author>
+				<firstname>Warren</firstname>
+				<surname>Young</surname>
+			</author>
+		</authorgroup>
+
+		<copyright>
+			<year>1998-2001, 2005-2008</year>
+			<holder>Kevin Atkinson (original author)</holder>
+			<holder>MySQL AB</holder>
+			<holder>Educational Technology Resources</holder>
+		</copyright>
+
+		<pubdate><?dbtimestamp format="B d, Y"?></pubdate>
+	</articleinfo>
+
+
+	<xi:include href="intro.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="overview.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="tutorial.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="tquery.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="ssqls.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="unicode.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="threads.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="configuration.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="breakages.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="licenses.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+</article>

ADDED   doc/userman/userman.dbx.in
Index: doc/userman/userman.dbx.in
==================================================================
--- /dev/null
+++ doc/userman/userman.dbx.in
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding='UTF-8'?>
+<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook V4.3//EN"
+    "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
+
+<article>
+	<articleinfo>
+		<title>MySQL++ v@MYSQLPP_VERSION_MAJOR@.@MYSQLPP_VERSION_MINOR@.@MYSQLPP_VERSION_BUGFIX@ User Manual</title>
+
+		<authorgroup>
+			<author>
+				<firstname>Kevin</firstname>
+				<surname>Atkinson</surname>
+			</author>
+
+			<author>
+				<firstname>Sinisa</firstname>
+				<surname>Milivojevic</surname>
+			</author>
+
+			<author>
+				<firstname>Monty</firstname>
+				<surname>Widenius</surname>
+			</author>
+
+			<author>
+				<firstname>Warren</firstname>
+				<surname>Young</surname>
+			</author>
+		</authorgroup>
+
+		<copyright>
+			<year>1998-2001, 2005-2008</year>
+			<holder>Kevin Atkinson (original author)</holder>
+			<holder>MySQL AB</holder>
+			<holder>Educational Technology Resources</holder>
+		</copyright>
+
+		<pubdate><?dbtimestamp format="B d, Y"?></pubdate>
+	</articleinfo>
+
+
+	<xi:include href="intro.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="overview.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="tutorial.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="tquery.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="ssqls.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="unicode.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="threads.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="configuration.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="breakages.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+	<xi:include href="licenses.dbx" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+</article>

ADDED   dtest
Index: dtest
==================================================================
--- /dev/null
+++ dtest
@@ -0,0 +1,80 @@
+#!/bin/bash
+
+TMP=`mktemp bmXXXXXX`
+
+# Run simple unit tests first.
+typeset -i count=0
+echo -n 'Running unit tests:'
+for t in test_*
+do
+	if [ -x "$t" ]
+	then
+		errmsg=`./exrun "$t" 2>&1`
+		errno=$?
+		if [ "$errno" = 0 ]
+		then
+			count=count+1
+		else
+			rm -f $TMP
+			echo " $t FAILED ($errno)"
+			echo
+			echo "$errmsg"
+			exit $?
+		fi
+	fi
+done
+echo " $count tests succeeded"
+echo 'All unit tests passed' >> $TMP
+
+
+# Now run examples to test high-level behavior.  The repeated use of
+# resetdb is intentional!  It's run after each example that changes
+# the database in a way that will cause a subsequent example to fail
+# because data it expects isn't present.
+echo -n 'Running examples:'
+for t in \
+	resetdb simple[0-9] store_if for_each multiquery tquery1 \
+	resetdb tquery[2-9] \
+	resetdb ssqls[0-9]
+do
+	if [ -x $t ]
+	then
+		if [ "$t" = "resetdb" ]
+		then
+			echo
+			echo -n "   "
+		fi
+	
+		echo -n "$t "
+		echo "---------------- BEGIN $t OUTPUT ----------------" >> $TMP
+		if ! ./exrun $t -D $* >> $TMP
+		then
+			echo
+			echo 'TESTING ABORTED.'
+			rm -f $TMP
+			exit $?
+		fi
+		echo "================ END $t OUTPUT ================" >> $TMP
+		echo >> $TMP
+	fi
+done
+echo
+
+
+# Check for any changes
+BFILE=bmark.txt
+if [ -f $BFILE ]
+then
+	if diff -u -w $BFILE $TMP
+	then
+		echo
+		echo 'All tests passed.'
+	fi
+	rm -f $TMP
+else
+	mv $TMP $BFILE
+	chmod -w $BFILE
+	echo
+	echo 'BENCHMARK FILE REGENERATED.'
+	echo
+fi

DELETED examples/Makefile.am
Index: examples/Makefile.am
==================================================================
--- examples/Makefile.am
+++ /dev/null
@@ -1,51 +0,0 @@
-
-include ../Configure
-
-noinst_PROGRAMS = resetdb simple1 custom1 custom2 custom3 custom4 complic1 fieldinf1
-
-noinst_HEADERS = util.hh
-
-simple1_SOURCES = simple1.cc
-simple1_LDFLAGS = 
-simple1_LDADD = $(SQLPLUSLIBS)
-simple1_DEPENDENCIES = $(SQLPLUSLIBS)
-
-sinisa_ex_SOURCES = sinisa_ex.cc
-sinisa_ex_LDFLAGS = 
-sinisa_ex_LDADD = $(SQLPLUSLIBS)
-sinisa_ex_DEPENDENCIES = $(SQLPLUSLIBS)
-
-resetdb_SOURCES = resetdb.cc util.cc
-resetdb_LDFLAGS = 
-resetdb_LDADD = $(SQLPLUSLIBS)
-resetdb_DEPENDENCIES = $(SQLPLUSLIBS)
-
-custom1_SOURCES = custom1.cc
-custom1_LDFLAGS = 
-custom1_LDADD = $(SQLPLUSLIBS)
-custom1_DEPENDENCIES = $(SQLPLUSLIBS)
-
-custom2_SOURCES = custom2.cc util.cc
-custom2_LDFLAGS = 
-custom2_LDADD = $(SQLPLUSLIBS)
-custom2_DEPENDENCIES = $(SQLPLUSLIBS)
-
-custom3_SOURCES = custom3.cc util.cc
-custom3_LDFLAGS = 
-custom3_LDADD = $(SQLPLUSLIBS)
-custom3_DEPENDENCIES = $(SQLPLUSLIBS)
-
-custom4_SOURCES = custom4.cc
-custom4_LDFLAGS = 
-custom4_LDADD = $(SQLPLUSLIBS)
-custom4_DEPENDENCIES = $(SQLPLUSLIBS)
-
-complic1_SOURCES = complic1.cc
-complic1_LDFLAGS = 
-complic1_LDADD = $(SQLPLUSLIBS)
-complic1_DEPENDENCIES = $(SQLPLUSLIBS)
-
-fieldinf1_SOURCES = fieldinf1.cc
-fieldinf1_LDFLAGS = 
-fieldinf1_LDADD = $(SQLPLUSLIBS)
-fieldinf1_DEPENDENCIES = $(SQLPLUSLIBS)

ADDED   examples/cgi_jpeg.cpp
Index: examples/cgi_jpeg.cpp
==================================================================
--- /dev/null
+++ examples/cgi_jpeg.cpp
@@ -0,0 +1,105 @@
+/***********************************************************************
+ cgi_jpeg.cpp - Example code showing how to fetch JPEG data from a BLOB
+ 	column and send it back to a browser that requested it by ID.
+	
+	Use load_jpeg.cpp to load JPEG files into the database we query.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+#include <ssqls.h>
+
+#define IMG_DATABASE	"mysql_cpp_data"
+#define IMG_HOST		"localhost"
+#define IMG_USER		"root"
+#define IMG_PASSWORD 	"nunyabinness"
+
+sql_create_2(images,
+	1, 2,
+	mysqlpp::sql_int_unsigned, id,
+	mysqlpp::sql_blob, data)
+
+int main()
+{
+	unsigned int img_id = 0;
+	char* cgi_query = getenv("QUERY_STRING");
+	if (cgi_query) {
+		if ((strlen(cgi_query) < 4) || memcmp(cgi_query, "id=", 3)) {
+			std::cout << "Content-type: text/plain" << std::endl << std::endl;
+			std::cout << "ERROR: Bad query string" << std::endl;
+			return 1;
+		}
+		else {
+			img_id = atoi(cgi_query + 3);
+		}
+	}
+	else {
+		std::cerr << "Put this program into a web server's cgi-bin "
+				"directory, then" << std::endl;
+		std::cerr << "invoke it with a URL like this:" << std::endl;
+		std::cerr << std::endl;
+		std::cerr << "    http://server.name.com/cgi-bin/cgi_jpeg?id=2" <<
+				std::endl;
+		std::cerr << std::endl;
+		std::cerr << "This will retrieve the image with ID 2." << std::endl;
+		std::cerr << std::endl;
+		std::cerr << "You will probably have to change some of the #defines "
+				"at the top of" << std::endl;
+		std::cerr << "examples/cgi_jpeg.cpp to allow the lookup to work." <<
+				std::endl;
+		return 1;
+	}
+
+	try {
+		mysqlpp::Connection con(IMG_DATABASE, IMG_HOST, IMG_USER,
+				IMG_PASSWORD);
+		mysqlpp::Query query = con.query();
+		query << "SELECT * FROM images WHERE id = " << img_id;
+		mysqlpp::UseQueryResult res = query.use();
+		if (res) {
+			images img = res.fetch_row();
+			std::cout << "Content-type: image/jpeg" << std::endl;
+			std::cout << "Content-length: " << img.data.length() << "\n\n";
+			std::cout << img.data;
+		}
+		else {
+			std::cout << "Content-type: text/plain" << std::endl << std::endl;
+			std::cout << "ERROR: No such image with ID " << img_id << std::endl;
+		}
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		std::cout << "Content-type: text/plain" << std::endl << std::endl;
+		std::cout << "QUERY ERROR: " << er.what() << std::endl;
+		return 1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		std::cout << "Content-type: text/plain" << std::endl << std::endl;
+		std::cout << "GENERAL ERROR: " << er.what() << std::endl;
+		return 1;
+	}
+
+	return 0;
+}

ADDED   examples/cmdline.cpp
Index: examples/cmdline.cpp
==================================================================
--- /dev/null
+++ examples/cmdline.cpp
@@ -0,0 +1,174 @@
+/***********************************************************************
+ cmdline.cpp - Utility functions for printing out data in common
+    formats, required by most of the example programs.
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+
+#include <iostream>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+//// globals and constants /////////////////////////////////////////////
+
+bool dtest_mode = false;		// true when running under dtest
+int run_mode = 0;				// -m switch's value
+const char* kpcSampleDatabase = "mysql_cpp_data";
+
+
+//// att_getopt ////////////////////////////////////////////////////////
+// An implementation of getopt(), included here so we don't have to
+// limit ourselves to platforms that provide this natively.  It is
+// adapted from the public domain getopt() implementation presented at
+// the 1985 UNIFORUM conference in Dallas, Texas.  It's been reformatted
+// and reworked a bit to fit in with MySQL++.
+
+static const char* ag_optarg;
+int ag_optind = 1;
+
+static int
+att_getopt(int argc, char* const argv[], const char* ag_opts)
+{
+	static int optopt;
+	static int sp = 1;
+	register int c;
+	register const char *cp;
+
+	if (sp == 1) {
+		/* If all args are processed, finish */
+		if (ag_optind >= argc) {
+			return EOF;
+		}
+		if (argv[ag_optind][0] != '-' || argv[ag_optind][1] == '\0') {
+			return EOF;
+		}
+	}
+	else if (!strcmp(argv[ag_optind], "--")) {
+		/* No more ag_options to be processed after this one */
+		ag_optind++;
+		return EOF;
+	}
+
+	optopt = c = argv[ag_optind][sp];
+
+	/* Check for invalid ag_option */
+	if (c == ':' || (cp = strchr(ag_opts, c)) == NULL) {
+		fprintf(stderr, "%s: illegal option -- %c\n", argv[0], c);
+		if (argv[ag_optind][++sp] == '\0') {
+			ag_optind++;
+			sp = 1;
+		}
+
+		return '?';
+	}
+
+	/* Does this ag_option require an argument? */
+	if (*++cp == ':') {
+		/* If so, get argument; if none provided output error */
+		if (argv[ag_optind][sp + 1] != '\0') {
+			ag_optarg = &argv[ag_optind++][sp + 1];
+		}
+		else if (++ag_optind >= argc) {
+			fprintf(stderr,
+					"%s: option requires an argument -- %c\n", argv[0], c);
+			sp = 1;
+			return '?';
+		}
+		else {
+			ag_optarg = argv[ag_optind++];
+		}
+		sp = 1;
+	}
+	else {
+		if (argv[ag_optind][++sp] == '\0') {
+			sp = 1;
+			ag_optind++;
+		}
+		ag_optarg = NULL;
+	}
+
+	return c;
+}
+
+
+//// print_usage ///////////////////////////////////////////////////////
+// Show the program's usage message
+
+void
+print_usage(const char* program_name, const char* extra_parms)
+{
+	std::cout << "usage: " << program_name <<
+			" [-s server_addr] [-u user] [-p password] " <<
+			extra_parms << std::endl;
+	std::cout << std::endl;
+	std::cout << "    If no options are given, connects to database "
+			"server on localhost" << std::endl;
+	std::cout << "    using your user name and no password." << std::endl;
+	if (strlen(extra_parms) > 0) {
+		std::cout << std::endl;
+		std::cout << "    The extra parameter " << extra_parms <<
+				" is required, regardless of which" << std::endl;
+		std::cout << "    other arguments you pass." << std::endl;
+	}
+	std::cout << std::endl;
+}
+
+
+//// parse_command_line ////////////////////////////////////////////////
+// Wrapper around att_getopt() to return the parameters needed to
+// connect to a database server and select the database itself.
+
+bool
+parse_command_line(int argc, char *argv[], const char** ppdb,
+        const char** ppserver, const char** ppuser, const char** pppass,
+        const char* extra_parms)
+{
+	if (argc < 1) {
+		std::cerr << "Bad argument count: " << argc << '!' << std::endl;
+		return false;
+	}
+
+	if (ppdb && !*ppdb) {
+		*ppdb = "mysql_cpp_data";       // use default DB
+	}
+
+	int ch;
+	while ((ch = att_getopt(argc, argv, "m:p:s:u:D")) != EOF) {
+		switch (ch) {
+			case 'm': run_mode = atoi(ag_optarg); break;
+			case 'p': *pppass = ag_optarg;        break;
+			case 's': *ppserver = ag_optarg;      break;
+			case 'u': *ppuser = ag_optarg;        break;
+			case 'D': dtest_mode = true;          break;
+			default:
+				print_usage(argv[0], extra_parms);
+				return false;
+		}
+	}
+
+	return true;
+}

ADDED   examples/cmdline.h
Index: examples/cmdline.h
==================================================================
--- /dev/null
+++ examples/cmdline.h
@@ -0,0 +1,40 @@
+/***********************************************************************
+ cmdline.h - Declares the interface to the command line parsing logic.
+    It is not important for a new MySQL++ user to understand any of what
+    goes on inside this module.  The examples just pass in the command 
+    line arguments and magically get out the proper database server
+    login parameters and the name of the database itself.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_CMDLINE_H)
+#define MYSQLPP_CMDLINE_H
+
+extern bool parse_command_line(int argc, char *argv[],
+        const char** ppdb, const char** ppserver, const char** ppuser,
+        const char** pppass, const char* extra_parms = "");
+extern void print_usage(const char* program_name,
+		const char* extra_parms = "");
+
+#endif // !defined(MYSQLPP_CMDLINE_H)
+

DELETED examples/complic1.cc
Index: examples/complic1.cc
==================================================================
--- examples/complic1.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-
-#include <iostream>
-#include <iomanip>
-#include <sqlplus.hh>
-
-int main() {
-  try { // its in one big try block
-
-    Connection con(use_exceptions);
-    con.connect("mysql_cpp_data");
-    // Here I broke making the connection into two calls.
-    // The first one creates the Connection object with the 
-    // use exceptions option turned on and the second one
-    // makes the connection
-    
-    Query query = con.query();
-    
-    query << "select * from stock";
-    Result res = query.store();
-    
-    cout << "Query: " << query.preview() << endl;
-    cout << "Records Found: " << res.size() << endl << endl;
-    
-    Row row;
-    cout.setf(ios::left);
-    cout << setw(17) << "Item" 
-       << setw(4)  << "Num"
-       << setw(7)  << "Weight"
-       << setw(7)  << "Price" 
-       << "Date" << endl
-       << endl;
-  
-    Result::iterator i;
-    
-    cout.precision(3);
-    for (i = res.begin(); i != res.end(); i++) {
-      row = *i;
-      cout << setw(17) << row["item"] << setw(4) << row[1] 
-	   << setw(7)  << (double)row[2]
-	// This is converting the row to a double so that we
-	// can set the precision of it.  
-	// ColData has the nice feature that it will convert to
-	// any of the basic c++ types.  if there is a problem
-	// in the conversion it will throw an exception (which I 
-	// cache below).  To test it try changing the 2 in row[2]
-	// to row[0]
-	   << setw(7) << (double)row[3];
-      Date date = row["sdate"]; 
-      // The ColData is implicitly converted to a date here.
-      cout.setf(ios::right);
-      cout.fill('0');
-      cout << setw(2) << date.month << "-" << setw(2) << date.day << endl;
-      cout.fill(' ');
-      cout.unsetf(ios::right);
-    }
-    return 0;
-  } catch (BadQuery er) { // handle any connection or
-                          // query errors that may come up
-    cerr << "Error: " << er.error << endl;
-    return -1;
-  } catch (BadConversion er) { // handle bad conversions
-    cerr << "Error: Tried to convert \"" << er.data << "\" to a \"" 
-	 << er.type_name << "\"." << endl;
-    return -1;
-  }
-}
-
-

ADDED   examples/cpool.cpp
Index: examples/cpool.cpp
==================================================================
--- /dev/null
+++ examples/cpool.cpp
@@ -0,0 +1,253 @@
+/***********************************************************************
+ cpool.cpp - ConnectionPool example.  Works with both Windows native
+	threads and POSIX threads.  Shows how to create and use a concrete
+	ConnectionPool derivative.
+
+ Copyright (c) 2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "threads.h"
+
+#include <iostream>
+
+using namespace std;
+
+
+#if defined(HAVE_THREADS)
+// Define a concrete ConnectionPool derivative.  Takes connection
+// parameters as inputs to its ctor, which it uses to create the
+// connections we're called upon to make.  Note that we also declare
+// a global pointer to an object of this type, which we create soon
+// after startup; this should be a common usage pattern, as what use
+// are multiple pools?
+class SimpleConnectionPool : public mysqlpp::ConnectionPool
+{
+public:
+	// The object's only constructor
+	SimpleConnectionPool(const char* db, const char* server,
+			const char* user, const char* password) :
+	conns_in_use_(0),
+	db_(db ? db : ""),
+	server_(server ? server : ""),
+	user_(user ? user : ""),
+	password_(password ? password : "")
+	{
+	}
+
+	// The destructor.  We _must_ call ConnectionPool::clear() here,
+	// because our superclass can't do it for us.
+	~SimpleConnectionPool()
+	{
+		clear();
+	}
+
+	// Do a simple form of in-use connection limiting: wait to return
+	// a connection until there are a reasonably low number in use
+	// already.  Can't do this in create() because we're interested in
+	// connections actually in use, not those created.  Also note that
+	// we keep our own count; ConnectionPool::size() isn't the same!
+	mysqlpp::Connection* grab()
+	{
+		while (conns_in_use_ > 8) {
+			cout.put('R'); cout.flush(); // indicate waiting for release
+			sleep(1);
+		}
+
+		++conns_in_use_;
+		return mysqlpp::ConnectionPool::grab();
+	}
+
+	// Other half of in-use conn count limit
+	void release(const mysqlpp::Connection* pc)
+	{
+		mysqlpp::ConnectionPool::release(pc);
+		--conns_in_use_;
+	}
+
+protected:
+	// Superclass overrides
+	mysqlpp::Connection* create()
+	{
+		// Create connection using the parameters we were passed upon
+		// creation.  This could be something much more complex, but for
+		// the purposes of the example, this suffices.
+		cout.put('C'); cout.flush(); // indicate connection creation
+		return new mysqlpp::Connection(
+				db_.empty() ? 0 : db_.c_str(),
+				server_.empty() ? 0 : server_.c_str(),
+				user_.empty() ? 0 : user_.c_str(),
+				password_.empty() ? "" : password_.c_str());
+	}
+
+	void destroy(mysqlpp::Connection* cp)
+	{
+		// Our superclass can't know how we created the Connection, so
+		// it delegates destruction to us, to be safe.
+		cout.put('D'); cout.flush(); // indicate connection destruction
+		delete cp;
+	}
+
+	unsigned int max_idle_time()
+	{
+		// Set our idle time at an example-friendly 3 seconds.  A real
+		// pool would return some fraction of the server's connection
+		// idle timeout instead.
+		return 3;
+	}
+
+private:
+	// Number of connections currently in use
+	unsigned int conns_in_use_;
+
+	// Our connection parameters
+	std::string db_, server_, user_, password_;
+};
+SimpleConnectionPool* poolptr = 0;
+
+
+static thread_return_t CALLBACK_SPECIFIER
+worker_thread(thread_arg_t running_flag)
+{
+	// Ask the underlying C API to allocate any per-thread resources it
+	// needs, in case it hasn't happened already.  In this particular
+	// program, it's almost guaranteed that the grab() call below will
+	// create a new connection the first time through, and thus allocate
+	// these resources implicitly, but there's a nonzero chance that
+	// this won't happen.  Anyway, this is an example program, meant to
+	// show good style, so we take the high road and ensure the
+	// resources are allocated before we do any queries.
+	mysqlpp::Connection::thread_start();
+	cout.put('S'); cout.flush(); // indicate thread started
+
+	// Pull data from the sample table a bunch of times, releasing the
+	// connection we use each time.
+	for (size_t i = 0; i < 6; ++i) {
+		// Go get a free connection from the pool, or create a new one
+		// if there are no free conns yet.
+		mysqlpp::Connection* cp = poolptr->grab();
+		if (!cp) {
+			cerr << "Failed to get a connection from the pool!" << endl;
+			break;
+		}
+
+		// Pull a copy of the sample stock table and print a dot for
+		// each row in the result set.
+		mysqlpp::Query query(cp->query("select * from stock"));
+		mysqlpp::StoreQueryResult res = query.store();
+		for (size_t j = 0; j < res.num_rows(); ++j) {
+			cout.put('.');
+		}
+
+		// Immediately release the connection once we're done using it.
+		// If we don't, the pool can't detect idle connections reliably.
+		poolptr->release(cp);
+
+		// Delay 1-4 seconds before doing it again.  Because this can
+		// delay longer than the idle timeout, we'll occasionally force
+		// the creation of a new connection on the next loop.
+		sleep(rand() % 4 + 1);	
+	}
+
+	// Tell main() that this thread is no longer running
+	*reinterpret_cast<bool*>(running_flag) = false;
+	cout.put('E'); cout.flush(); // indicate thread ended
+	
+	// Release the per-thread resources before we exit
+	mysqlpp::Connection::thread_end();
+
+	return 0;
+}
+#endif
+
+
+int
+main(int argc, char *argv[])
+{
+#if defined(HAVE_THREADS)
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	// Create the pool and grab a connection.  We do it partly to test
+	// that the parameters are good before we start doing real work, and
+	// partly because we need a Connection object to call thread_aware()
+	// on to check that it's okay to start doing that real work.  This
+	// latter check should never fail on Windows, but will fail on most
+	// other systems unless you take positive steps to build with thread
+	// awareness turned on.  See README-*.txt for your platform.
+	poolptr = new SimpleConnectionPool(db, server, user, pass);
+	try {
+		mysqlpp::Connection* cp = poolptr->grab();
+		if (!cp->thread_aware()) {
+			cerr << "MySQL++ wasn't built with thread awareness!  " <<
+					argv[0] << " can't run without it." << endl;
+			return 1;
+		}
+		poolptr->release(cp);
+	}
+	catch (mysqlpp::Exception& e) {
+		cerr << "Failed to set up initial pooled connection: " <<
+				e.what() << endl;
+		return 1;
+	}
+
+	// Setup complete.  Now let's spin some threads...
+	cout << endl << "Pool created and working correctly.  Now to do "
+			"some real work..." << endl;
+	srand(time(0));
+	bool running[] = {
+			true, true, true, true, true, true, true,
+			true, true, true, true, true, true, true };
+	const size_t num_threads = sizeof(running) / sizeof(running[0]);
+	size_t i;
+	for (i = 0; i < num_threads; ++i) {
+		if (int err = create_thread(worker_thread, running + i)) {
+			cerr << "Failed to create thread " << i <<
+					": error code " << err << endl;
+			return 1;
+		}
+	}
+
+	// Test the 'running' flags every second until we find that they're
+	// all turned off, indicating that all threads are stopped.
+	cout.put('W'); cout.flush(); // indicate waiting for completion
+	do {
+		sleep(1);
+		i = 0;
+		while (i < num_threads && !running[i]) ++i;
+	}
+	while (i < num_threads);
+	cout << endl << "All threads stopped!" << endl;
+
+	// Shut it all down...
+	delete poolptr;
+	cout << endl;
+#else
+	(void)argc;		// warning squisher
+	cout << argv[0] << " requires that threads be enabled!" << endl;
+#endif
+
+	return 0;
+}

DELETED examples/custom1.cc
Index: examples/custom1.cc
==================================================================
--- examples/custom1.cc
+++ /dev/null
@@ -1,78 +0,0 @@
-
-#include <iostream>
-#include <iomanip>
-#include <vector>
-#include <sqlplus.hh>
-#include <custom.hh>
-
-sql_create_5 (stock,		// struct name, 
-	      1, 5,		// I'll explain these latter
-	      string, item,	// type, id
-	      int, num,
-	      double, weight,
-	      double, price,
-	      Date, sdate)
-
-// this is calling a very complex macro which will create a custom
-// struct "stock" which has the variables:
-//   string item
-//    int num
-//    ...
-//    Date sdate
-// defined as well methods to help populate the class from a mysql row
-// among other things that I'll get too in a latter example
-
-int main () {
-  try {				// its in one big try block
-    Connection con (use_exceptions);
-    con.connect ("mysql_cpp_data");
-    Query query = con.query ();
-    query << "select * from stock";
-
-    vector < stock > res;
-    query.storein (res);
-    // this is storing the results into a vector of the custom struct
-    // "stock" which was created my the macro above.
-
-    cout.setf (ios::left);
-    cout << setw (17) << "Item"
-	 << setw (4) << "Num"
-	 << setw (7) << "Weight"
-	 << setw (7) << "Price"
-	 << "Date" << endl
-	 << endl;
-
-    // Now we we iterate through the vector using an iterator and
-    // produce output similar to that using Row
-    // Notice how we call the actual variables in i and not an index
-    // offset.  This is because the macro at the begging of the file
-    // set up an *actual* struct of type stock which contains the 
-    // variables item, num, weight, price, and data.
-
-    cout.precision(3);
-    vector <stock>::iterator i;
-    for (i = res.begin (); i != res.end (); i++) {
-      cout << setw (17) << i->item.c_str ()
-	// unfortunally the gnu string class does not respond to format
-	// modifers so I have to convert it to a conat char *.
-	   << setw (4) << i->num
-	   << setw (7) << i->weight
-	   << setw (7) << i->price
-	   << i->sdate
-	   << endl;
-    }
-    return 0;
-    
-  } catch (BadQuery er){ // handle any connection 
-                         // or query errors that may come up
-    cerr << "Error: " << er.error << endl;
-    return -1;
-
-  } catch (BadConversion er) {
-    // we still need to cache bad conversions incase something goes 
-    // wrong when the data is converted into stock
-    cerr << "Error: Tried to convert \"" << er.data << "\" to a \""
-	 << er.type_name << "\"." << endl;
-    return -1;
-  }
-}

DELETED examples/custom2.cc
Index: examples/custom2.cc
==================================================================
--- examples/custom2.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-
-#include <iostream>
-#include <vector>
-#include <sqlplus.hh>
-#include <custom.hh>
-#include "util.hh"
-// util.hh/cc contains the print_stock_table function
-
-sql_create_5(stock, 1, 5, string, item, int, num, 
-	     double, weight, double, price, Date, sdate)
-
-int main() {
-  try { // its in one big try block
-
-    Connection con(use_exceptions);
-    con.connect("mysql_cpp_data");
-    Query query = con.query();
-
-    stock row;
-    // create an empty stock object
-    
-    /*    row.item = "Hot Dogs";
-    row.num = 100;
-    row.weight = 1.5;
-    row.price = 1.75;
-    row.sdate = "1998-09-25"; */
-    row.set("Hot Dogs", 100, 1.5, 1.75, "1998-09-25");
-    // populate stock
-
-    query.insert(row);
-    // form the query to insert the row
-    // the table name is the name of the struct by default
-    cout << "Query : " << query.preview() << endl;
-    // show the query about to be executed
-    query.execute();
-    // execute a query that does not return a result set
-
-    print_stock_table(query);
-    // now print the new table;
-    
-  } catch (BadQuery er) {
-    cerr << "Error: " << er.error << endl;
-    return -1;
-  } catch (BadConversion er) { 
-    cerr << "Error: Tried to convert \"" << er.data << "\" to a \"" 
-	 << er.type_name << "\"." << endl;
-    return -1;
-  }
-}

DELETED examples/custom3.cc
Index: examples/custom3.cc
==================================================================
--- examples/custom3.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-
-#include <iostream>
-#include <vector>
-#include <sqlplus.hh>
-#include <custom.hh>
-#include "util.hh"
-// util.hh/cc contains the print_stock_table function
-
-sql_create_5(stock, 1, 5, string, item, int, num, 
-	     double, weight, double, price, Date, sdate)
-
-int main() {
-  try { // its in one big try block
-
-    Connection con(use_exceptions);
-    con.connect("mysql_cpp_data");
-    Query query = con.query();
-
-    query << "select * from stock where item = \"Hotdogs' Buns\" ";
-    
-    Result res = query.store();
-    if (res.empty()) 
-      throw BadQuery("Hotdogs' Buns not found in table, run reset-db");
-    // here we are testing if the query was successful, if not throw a bad query
-    stock row = res[0];
-    // because there should only be one row in this query we don't
-    // need to use a vector.  Just store the first row directly in
-    // "row".  We can do this because one of the constructors for
-    // stock takes a Row as an parameter.
-
-    stock row2 = row;
-    // Now we need to create a copy so that the replace query knows
-    // what the original values are.
-
-    row.item = "Hotdog Buns"; // now change item
-
-    query.update(row2, row);
-    // form the query to replace the row
-    // the table name is the name of the struct by default
-    cout << "Query : " << query.preview() << endl;
-    // show the query about to be executed
-    query.execute();
-    // execute a query that does not return a result set
-
-    print_stock_table(query);
-    // now print the new table;
-    
-  } catch (BadQuery er) {
-    cerr << "Error: " << er.error << endl;
-    return -1;
-  } catch (BadConversion er) { 
-    cerr << "Error: Tried to convert \"" << er.data << "\" to a \"" 
-	 << er.type_name << "\"." << endl;
-    return -1;
-  }
-}

DELETED examples/custom4.cc
Index: examples/custom4.cc
==================================================================
--- examples/custom4.cc
+++ /dev/null
@@ -1,73 +0,0 @@
-
-#include <iostream>
-#include <iomanip>
-#include <vector>
-#include <sqlplus.hh>
-#include <custom.hh>
-
-sql_create_5(stock, 
-	     1, // This number is used to make a SSQLS less-than-comparable.
-	        // If this number is n then if the first n elements are the 
-	        // same the two SSQLS are the same.  
-	        // In this case if two two stock's "item" are the same then
-	        // the two stock are the same.
-	     5, // this number should generally be the same as the number of
-	        // elements in the list unless you have a good reason not to.
-
-	     string,item,  int,num,  double,weight,  double,price,  Date,sdate)
-
-int main() {
-  try { // its in one big try block
-
-    Connection con(use_exceptions);
-    con.connect("mysql_cpp_data");
-    Query query = con.query();
-
-    query << "select * from stock";
-    
-    set<stock> res;
-    query.storein(res);
-    // here we are storing the elements in a set not a vector.
-
-    cout.setf (ios::left);
-    cout << setw (17) << "Item"
-	 << setw (4) << "Num"
-	 << setw (7) << "Weight"
-	 << setw (7) << "Price"
-	 << "Date" << endl
-	 << endl;
-
-    // Now we we iterate through the set.  Since it is a set the list will
-    // naturally be in order.
-    
-    set<stock>::iterator i;
-    cout.precision(3);
-    for (i = res.begin (); i != res.end (); i++) {
-      cout << setw (17) << i->item.c_str ()
-	   << setw (4) << i->num
-	   << setw (7) << i->weight
-	   << setw (7) << i->price
-	   << i->sdate
-	   << endl;
-    }
-
-    i = res.find(stock("Hamburger Buns"));
-    if (i != res.end())
-      cout << "Hamburger Buns found.  Currently " << i->num << " in stock.\n";
-    else
-      cout << "Sorry no Hamburger Buns found in stock\n";
-
-    // Now we are using the set's find method to find out how many
-    // Hamburger Buns are in stock.
-
-    return 0;
-
-  } catch (BadQuery er) {
-    cerr << "Error: " << er.error << endl;
-    return -1;
-  } catch (BadConversion er) { 
-    cerr << "Error: Tried to convert \"" << er.data << "\" to a \"" 
-	 << er.type_name << "\"." << endl;
-    return -1;
-  }
-}

ADDED   examples/dbinfo.cpp
Index: examples/dbinfo.cpp
==================================================================
--- /dev/null
+++ examples/dbinfo.cpp
@@ -0,0 +1,190 @@
+/***********************************************************************
+ dbinfo.cpp - Example showing how to request information about the
+	database schema, such as table names, column types, etc.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <mysql++.h>
+
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+
+// Insert a bar into the stream with the given query string centered
+static void
+separator(ostream& os, string qstr)
+{
+	string sep("========================================"
+			"========================================");
+	if (qstr.size()) {
+		string::size_type start = (sep.size() - qstr.size()) / 2;
+		sep.replace(start - 1, 1, 1, ' ');
+		sep.replace(start, qstr.size(), qstr);
+		sep.replace(start + qstr.size(), 1, 1, ' ');
+		os << "\n\n";
+	}
+	os << sep << endl;
+}
+
+
+// Print out the MySQL server version
+static void
+show_mysql_version(mysqlpp::Connection& con)
+{
+	separator(cout, "");
+    cout << "MySQL version: " << con.client_version();
+}
+
+
+// Print out the names of all the databases managed by the server
+static void
+show_databases(mysqlpp::Connection& con)
+{
+    mysqlpp::Query query = con.query("show databases");
+	separator(cout, query.str());
+    mysqlpp::StoreQueryResult res = query.store();
+
+    cout << "Databases found: " << res.size();
+    cout.setf(ios::left);
+    mysqlpp::StoreQueryResult::iterator rit;
+    for (rit = res.begin(); rit != res.end(); ++rit) {
+        cout << "\n\t" << (*rit)[0];
+    }
+}
+
+
+// Print information about each of the tables we found
+static void
+show_table_info(mysqlpp::Connection& con, const vector<string>& tables)
+{
+	vector<string>::const_iterator it;
+	for (it = tables.begin(); it != tables.end(); ++it) {
+		mysqlpp::Query query = con.query();
+		query << "describe " << *it;
+		separator(cout, query.str());
+		mysqlpp::StoreQueryResult res = query.store();
+
+		unsigned int columns = res.num_fields();
+		vector<int> widths;
+		for (unsigned int i = 0; i < columns; ++i) {
+			string s = res.field_name(i);
+			if (s.compare("field") == 0) {
+				widths.push_back(22);
+			}
+			else if (s.compare("type") == 0) {
+				widths.push_back(20);
+			}
+			else if (s.compare("null") == 0) {
+				widths.push_back(4);
+			}
+			else if (s.compare("key") == 0) {
+				widths.push_back(3);
+			}
+			else if (s.compare("extra") == 0) {
+				widths.push_back(0);
+			}
+			else {
+				widths.push_back(15);
+			}
+
+			if (widths[i]) {
+				cout << '|' << setw(widths[i]) << res.field_name(i) << '|';
+			}
+		}
+		cout << endl;
+
+		mysqlpp::StoreQueryResult::iterator rit;
+		for (rit = res.begin(); rit != res.end(); ++rit) {
+			for (unsigned int i = 0; i < columns; ++i) {
+				if (widths[i]) {
+					cout << ' ' << setw(widths[i]) <<
+							(*rit)[i].c_str() << ' ';
+				}
+			}
+			cout << endl;
+		}
+	}
+}
+
+
+// Print out the names of all tables in the sample database, and
+// return the list of tables.
+static void
+show_tables(mysqlpp::Connection& con)
+{
+    mysqlpp::Query query = con.query("show tables");
+	separator(cout, query.str());
+	mysqlpp::StoreQueryResult res = query.store();
+
+	cout << "Tables found: " << res.size();
+	cout.setf(ios::left);
+	vector<string> tables;
+    mysqlpp::StoreQueryResult::iterator rit;
+	for (rit = res.begin(); rit != res.end(); ++rit) {
+		string tbl((*rit)[0]);
+		cout << "\n\t" << tbl;
+		tables.push_back(tbl);
+	}
+
+	show_table_info(con, tables);
+}
+
+
+// Call all the above functions in sequence
+int
+main(int argc, char* argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Connect to server, then dump a bunch of stuff we find on it
+		mysqlpp::Connection con(db, server, user, pass);
+		show_mysql_version(con);
+		show_databases(con);
+		show_tables(con);
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/deadlock.cpp
Index: examples/deadlock.cpp
==================================================================
--- /dev/null
+++ examples/deadlock.cpp
@@ -0,0 +1,115 @@
+/***********************************************************************
+ deadlock.cpp - Demonstrates how MySQL's deadlock detection interacts
+ 	with MySQL++'s Transaction class an exception handling mechanism.
+	Run one copy of this program with the -m1 command line switch, then
+	while it's waiting for you to press Enter, run another copy with -m2
+	instead.
+
+ Copyright (c) 2007 by Jim Wallace and (c) 2007 by Educational
+ Technology Resources, Inc.  Others may also hold copyrights on code
+ in this file.  See the CREDITS file in the top directory of the
+ distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+
+#include <mysql++.h>
+#include <mysqld_error.h>
+
+#include <iostream>
+
+using namespace std;
+
+// Bring in global holding the value given to the -m switch
+extern int run_mode;
+
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	// Check that the mode parameter was also given and it makes sense
+	if ((run_mode != 1) && (run_mode != 2)) {
+		cerr << argv[0] << " must be run with -m1 or -m2 as one of "
+				"its command-line arguments." << endl;
+		return 1;
+	}
+
+	mysqlpp::Connection con;
+	try {
+		// Establish the connection to the database server
+		con.connect(db, server, user, pass);
+
+		// Start a transaction set.  Transactions create mutex locks on
+		// modified rows, so if two programs both touch the same pair of
+		// rows but in opposite orders at the wrong time, one of the two
+		// programs will deadlock.  The MySQL server knows how to detect
+		// this situation, and its error return causes MySQL++ to throw
+		// a BadQuery exception.  The point of this example is that if
+		// you want to detect this problem, you would check the value of
+		// BadQuery::errnum(), not Connection::errnum(), because the
+		// transaction rollback process executes a query which succeeds,
+		// setting the MySQL C API's "last error number" value to 0.
+		// The exception object carries its own copy of the error number
+		// at the point the exception was thrown for this very reason.
+		mysqlpp::Query query = con.query();
+		mysqlpp::Transaction trans(con);
+
+		// Build and run the queries, with the order depending on the -m
+		// flag, so that a second copy of the program will deadlock if
+		// run while the first is waiting for Enter.
+		char dummy[100];
+		for (int i = 0; i < 2; ++i) {
+			int lock = run_mode + (run_mode == 1 ? i : -i);
+			cout << "Trying lock " << lock << "..." << endl;
+
+			query << "select * from deadlock_test" << lock << 
+					" where x = " << lock << " for update";
+			query.store();
+
+			cout << "Acquired lock " << lock << ".  Press Enter to ";
+			cout << (i == 0 ? "try next lock" : "exit");
+			cout << ": " << flush;
+			cin.getline(dummy, sizeof(dummy));
+		}
+	}
+	catch (mysqlpp::BadQuery e) {
+        if (e.errnum() == ER_LOCK_DEADLOCK) {
+            cerr << "Transaction deadlock detected!" << endl;
+    		cerr << "Connection::errnum = " << con.errnum() <<
+	    			", BadQuery::errnum = " << e.errnum() << endl;
+        }
+        else {
+    		cerr << "Unexpected query error: " << e.what() << endl;
+        }
+		return 1;
+	}
+	catch (mysqlpp::Exception e) {
+		cerr << "General error: " << e.what() << endl;		
+		return 1;
+	}
+
+	return 0;
+}

ADDED   examples/fieldinf.cpp
Index: examples/fieldinf.cpp
==================================================================
--- /dev/null
+++ examples/fieldinf.cpp
@@ -0,0 +1,114 @@
+/***********************************************************************
+ fieldinf.cpp - Shows how to request information about the fields in a 
+    table, such as their SQL and C++-equivalent types.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Get contents of main example table
+		mysqlpp::Query query = con.query("select * from stock");
+		mysqlpp::StoreQueryResult res = query.store();
+
+		// Show info about each field in that table
+		char widths[] = { 12, 22, 46 };
+		cout.setf(ios::left);
+		cout << setw(widths[0]) << "Field" <<
+				setw(widths[1]) << "SQL Type" <<
+				setw(widths[2]) << "Equivalent C++ Type" <<
+				endl;
+		for (size_t i = 0; i < sizeof(widths) / sizeof(widths[0]); ++i) {
+			cout << string(widths[i] - 1, '=') << ' ';
+		}
+		cout << endl;
+		
+		for (size_t i = 0; i < res.field_names()->size(); i++) {
+			// Suppress C++ type name outputs when run under dtest,
+			// as they're system-specific.
+			const char* cname = res.field_type(i).name();
+			mysqlpp::FieldTypes::value_type ft = res.field_type(i);
+			ostringstream os;
+			os << ft.sql_name() << " (" << ft.id() << ')';
+			cout << setw(widths[0]) << res.field_name(i).c_str() <<
+					setw(widths[1]) << os.str() <<
+					setw(widths[2]) << cname <<
+					endl;
+		}
+		cout << endl;
+
+		// Simple type check
+		if (res.field_type(0) == typeid(string)) {
+			cout << "SQL type of 'item' field most closely resembles "
+					"the C++ string type." << endl;
+		}
+
+		// Tricky type check: the 'if' path shouldn't happen because the
+		// description field has the NULL attribute.  We need to dig a
+		// little deeper if we want to ignore this in our type checks.
+		if (res.field_type(5) == typeid(string)) {
+			cout << "Should not happen! Type check failure." << endl;
+		}
+		else if (res.field_type(5) == typeid(mysqlpp::Null<mysqlpp::String>)) {
+			cout << "SQL type of 'description' field resembles "
+					"a nullable variant of the C++ string type." << endl;
+		}
+		else {
+			cout << "Weird: fifth field's type is now " <<
+					res.field_type(5).name() << endl;
+			cout << "Did something recently change in resetdb?" << endl;
+		}
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

DELETED examples/fieldinf1.cc
Index: examples/fieldinf1.cc
==================================================================
--- examples/fieldinf1.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-
-#include <iostream>
-#include <iomanip>
-#include <sqlplus.hh>
-
-int main() {
-  try { // its in one big try block
-
-    Connection con(use_exceptions);
-    con.connect("mysql_cpp_data");
-    Query query = con.query();
-    query << "select * from stock";
-    Result res = query.store();
-    
-    cout << "Query: " << query.preview() << endl;
-    cout << "Records Found: " << res.size() << endl << endl;
-
-    cout << "Query Info:\n";
-    cout.setf(ios::left);
-
-    for (unsigned int i = 0; i < res.names().size(); i++) {
-      cout << setw(2)  << i
-	   << setw(15) << res.names(i).c_str()
-	// this is the name of the field
-	   << setw(15) << res.types(i).sql_name()
-	// this is the SQL identifier name
-	// Result::types(unsigned int) returns a mysql_type_info which in many
-	// ways is like type_info except that it has additional sql type
-	// information in it. (with one of the methods being sql_name())
-	   << setw(20) << res.types(i).name()
-	// this is the C++ identifier name which most closely resembles
-	// the sql name (its is implementation defined and often not very readable)
-	   << endl;
-    }
-
-    cout << endl;
-    
-    if (res.types(0) == typeid(string))
-      cout << "Field 'item' is of an sql type which most closely resembles a\n"
-	   << "the c++ string type\n";
-    // this is demonstrating how a mysql_type_info can be compared with a c++
-    // type_info.
-
-    if (res.types(1) == typeid(short int))
-      cout << "Field 'num' is of an sql type which most closely resembles a\n"
-	   << "the c++ short int type\n";
-    else if (res.types(1).base_type() == typeid(short int))
-      cout << "Field 'num' base type is of an sql type which most closely \n"
-	   << "resembles a the c++ short int type\n";
-    // However you have to be careful as if it can be null the actual type is 
-    // Null<TYPE> not TYPE.  So you should always use the base_type method
-    // to get at the underlying type.  If the type is not null than this base
-    // type would be the same as its type.
-    
-    return 0;
-  } catch (BadQuery er) {
-    cerr << "Error: " << er.error << endl;
-    return -1;
-  } catch (BadConversion er) { // handle bad conversions
-    cerr << "Error: Tried to convert \"" << er.data << "\" to a \"" 
-	 << er.type_name << "\"." << endl;
-    return -1;
-  }
-}
-
-

ADDED   examples/for_each.cpp
Index: examples/for_each.cpp
==================================================================
--- /dev/null
+++ examples/for_each.cpp
@@ -0,0 +1,108 @@
+/***********************************************************************
+ for_each.cpp - Demonstrates Query::for_each(), showing how to perform
+	an arbitrary action on each row in a result set.
+
+ Copyright (c) 2005-2008 by Educational Technology Resources, Inc. and
+ (c) 2007 by Joel Fielder.  Others may also hold copyrights on code
+ in this file.  See the CREDITS file in the top directory of the
+ distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+#include "stock.h"
+
+#include <mysql++.h>
+
+#include <iostream>
+
+#include <math.h>
+
+
+// Define a functor to collect statistics about the stock table
+class gather_stock_stats
+{
+public:
+	gather_stock_stats() :
+	items_(0),
+	weight_(0),
+	cost_(0)
+	{
+	}
+
+	void operator()(const stock& s)
+	{
+		items_  += s.num;
+		weight_ += (s.num * s.weight);
+		cost_   += (s.num * s.price);
+	}
+	
+private:
+	mysqlpp::sql_bigint items_;
+	mysqlpp::sql_double weight_, cost_;
+
+	friend std::ostream& operator<<(std::ostream& os,
+			const gather_stock_stats& ss);
+};
+
+
+// Dump the contents of gather_stock_stats to a stream in human-readable
+// form.
+std::ostream&
+operator<<(std::ostream& os, const gather_stock_stats& ss)
+{
+	os << ss.items_ << " items " <<
+			"weighing " << ss.weight_ << " stone and " <<
+			"costing " << ss.cost_ << " cowrie shells";
+	return os;
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Gather and display the stats for the entire stock table
+		mysqlpp::Query query = con.query();
+		std::cout << "There are " << query.for_each(stock(),
+				gather_stock_stats()) << '.' << std::endl;
+	}
+	catch (const mysqlpp::BadQuery& e) {
+		// Something went wrong with the SQL query.
+		std::cerr << "Query failed: " << e.what() << std::endl;
+		return 1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		std::cerr << "Error: " << er.what() << std::endl;
+		return 1;
+	}
+
+	return 0;
+}

ADDED   examples/load_jpeg.cpp
Index: examples/load_jpeg.cpp
==================================================================
--- /dev/null
+++ examples/load_jpeg.cpp
@@ -0,0 +1,137 @@
+/***********************************************************************
+ load_jpeg.cpp - Example showing how to insert BLOB data into the
+	database from a file.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
+ MySQL AB, and (c) 2004-2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <mysql++.h>
+
+#include <fstream>
+
+using namespace std;
+using namespace mysqlpp;
+
+
+// Pull in a state variable used by att_getopt() implementation so we
+// can pick up where standard command line processing leaves off.  Feel
+// free to ignore this implementation detail.
+extern int ag_optind;
+
+
+static bool
+is_jpeg(const unsigned char* img_data)
+{
+	return (img_data[0] == 0xFF) && (img_data[1] == 0xD8) &&
+			((memcmp(img_data + 6, "JFIF", 4) == 0) ||
+			 (memcmp(img_data + 6, "Exif", 4) == 0));
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass,
+			"[jpeg_file]")) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Assume that the last command line argument is a file.  Try
+		// to read that file's data into img_data, and check it to see
+		// if it appears to be a JPEG file.  Bail otherwise.
+		string img_name, img_data;
+		if (argc - ag_optind >= 1) {
+			img_name = argv[ag_optind];
+			ifstream img_file(img_name.c_str(), ios::ate);
+			if (img_file) {
+				size_t img_size = img_file.tellg();
+				if (img_size > 10) {
+					img_file.seekg(0, ios::beg);
+					unsigned char* img_buffer = new unsigned char[img_size];
+					img_file.read(reinterpret_cast<char*>(img_buffer),
+							img_size);
+					if (is_jpeg(img_buffer)) {
+						img_data.assign(
+								reinterpret_cast<char*>(img_buffer),
+								img_size);
+					}
+					else {
+						cerr << '"' << img_file <<
+								"\" isn't a JPEG!" << endl;
+					}
+					delete[] img_buffer;
+				}
+				else {
+					cerr << "File is too short to be a JPEG!" << endl;
+				}
+			}
+		}
+		if (img_data.empty()) {
+			print_usage(argv[0], "[jpeg_file]");
+			return 1;
+		}
+
+		// Insert image data into the BLOB column in the images table.
+		// We're inserting it as an std::string instead of using the raw
+		// data buffer allocated above because we don't want the data
+		// treated as a C string, which would truncate the data at the
+		// first null character.
+		Query query = con.query();
+		query << "INSERT INTO images (data) VALUES(\"" <<
+				mysqlpp::escape << img_data << "\")";
+		SimpleResult res = query.execute();
+
+		// If we get here, insertion succeeded
+		cout << "Inserted \"" << img_name <<
+				"\" into images table, " << img_data.size() <<
+				" bytes, ID " << res.insert_id() << endl;
+	}
+	catch (const BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const BadConversion& er) {
+		// Handle bad conversions
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/logo.jpg
Index: examples/logo.jpg
==================================================================
--- /dev/null
+++ examples/logo.jpg
cannot compute difference between binary files

ADDED   examples/multiquery.cpp
Index: examples/multiquery.cpp
==================================================================
--- /dev/null
+++ examples/multiquery.cpp
@@ -0,0 +1,207 @@
+/***********************************************************************
+ multiquery.cpp - Example showing how to iterate over result sets upon
+    execution of a query that returns more than one result set.  You can
+	get multiple result sets when executing multiple separate SQL
+	statments in a single query, or when dealing with the results of
+	calling a stored procedure.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
+ MySQL AB, (c) 2004, 2005 by Educational Technology Resources, Inc.,
+ and (c) 2005 by Arnon Jalon.  Others may also hold copyrights on
+ code in this file.  See the CREDITS file in the top directory of
+ the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <mysql++.h>
+
+#include <iostream>
+#include <iomanip>
+#include <vector>
+
+using namespace std;
+using namespace mysqlpp;
+
+
+typedef vector<int> IntVectorType;
+
+
+static void
+print_header(IntVectorType& widths, StoreQueryResult& res)
+{
+	cout << "  |" << setfill(' ');
+	for (size_t i = 0; i < res.field_names()->size(); i++) {
+		cout << " " << setw(widths.at(i)) << res.field_name(i) << " |";
+	}
+	cout << endl;
+}
+
+
+static void
+print_row(IntVectorType& widths, Row& row)
+{
+	cout << "  |" << setfill(' ');
+	for (size_t i = 0; i < row.size(); ++i) {
+		cout << " " << setw(widths.at(i)) << row[i] << " |";
+	}
+	cout << endl;
+}
+
+
+static void
+print_row_separator(IntVectorType& widths)
+{
+	cout << "  +" << setfill('-');
+	for (size_t i = 0; i < widths.size(); i++) {
+		cout << "-" << setw(widths.at(i)) << '-' << "-+";
+	}
+	cout << endl;
+}
+
+
+static void
+print_result(StoreQueryResult& res, int index)
+{
+	// Show how many rows are in result, if any
+	StoreQueryResult::size_type num_results = res.size();
+	if (res && (num_results > 0)) {
+		cout << "Result set " << index << " has " << num_results <<
+				" row" << (num_results == 1 ? "" : "s") << ':' << endl;
+	}
+	else {
+		cout << "Result set " << index << " is empty." << endl;
+		return;
+	}
+
+	// Figure out the widths of the result set's columns
+	IntVectorType widths;
+	int size = res.num_fields();
+	for (int i = 0; i < size; i++) {
+		widths.push_back(max(
+				res.field(i).max_length(),
+				res.field_name(i).size()));
+	}
+
+	// Print result set header
+	print_row_separator(widths);
+	print_header(widths, res);
+	print_row_separator(widths);
+
+	// Display the result set contents
+	for (StoreQueryResult::size_type i = 0; i < num_results; ++i) {
+		print_row(widths, res[i]);
+	}
+
+	// Print result set footer
+	print_row_separator(widths);
+}
+
+
+static void
+print_multiple_results(Query& query)
+{
+	// Execute query and print all result sets
+	StoreQueryResult res = query.store();
+	print_result(res, 0);
+	for (int i = 1; query.more_results(); ++i) {
+		res = query.store_next();
+		print_result(res, i);
+	}
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	// Get connection parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Enable multi-queries.  Notice that you almost always set
+		// MySQL++ connection options before establishing the server
+		// connection, and options are always set using this one
+		// interface.  If you're familiar with the underlying C API,
+		// you know that there is poor consistency on these matters;
+		// MySQL++ abstracts these differences away.
+		Connection con;
+		con.set_option(new MultiStatementsOption(true));
+
+		// Connect to the database
+		if (!con.connect(db, server, user, pass)) {
+			return 1;
+		}
+
+		// Set up query with multiple queries.
+		Query query = con.query();
+		query << "DROP TABLE IF EXISTS test_table; " <<
+				"CREATE TABLE test_table(id INT); " <<
+				"INSERT INTO test_table VALUES(10); " <<
+				"UPDATE test_table SET id=20 WHERE id=10; " <<
+				"SELECT * FROM test_table; " <<
+				"DROP TABLE test_table";
+		cout << "Multi-query: " << endl << query << endl;
+
+		// Execute statement and display all result sets.
+		print_multiple_results(query);
+
+#if MYSQL_VERSION_ID >= 50000
+		// If it's MySQL v5.0 or higher, also test stored procedures, which
+		// return their results the same way multi-queries do.
+		query << "DROP PROCEDURE IF EXISTS get_stock; " <<
+				"CREATE PROCEDURE get_stock" <<
+				"( i_item varchar(20) ) " <<
+				"BEGIN " <<
+				"SET i_item = concat('%', i_item, '%'); " <<
+				"SELECT * FROM stock WHERE lower(item) like lower(i_item); " <<
+				"END;";
+		cout << "Stored procedure query: " << endl << query << endl;
+
+		// Create the stored procedure.
+		print_multiple_results(query);
+
+		// Call the stored procedure and display its results.
+		query << "CALL get_stock('relish')";
+		cout << "Query: " << query << endl;
+		print_multiple_results(query);
+#endif
+
+		return 0;
+	}
+	catch (const BadOption& err) {
+		cerr << err.what() << endl;
+		cerr << "This example requires MySQL 4.1.1 or later." << endl;
+		return 1;
+	}
+	catch (const ConnectionFailed& err) {
+		cerr << "Failed to connect to database server: " <<
+				err.what() << endl;
+		return 1;
+	}
+	catch (const Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return 1;
+	}
+}

ADDED   examples/printdata.cpp
Index: examples/printdata.cpp
==================================================================
--- /dev/null
+++ examples/printdata.cpp
@@ -0,0 +1,116 @@
+/***********************************************************************
+ printdata.cpp - Utility functions for printing out data in common
+    formats, required by most of the example programs.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "printdata.h"
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+
+//// print_stock_header ////////////////////////////////////////////////
+// Display a header suitable for use with print_stock_rows().
+
+void
+print_stock_header(int rows)
+{
+	cout << "Records found: " << rows << endl << endl;
+	cout.setf(ios::left);
+	cout << setw(31) << "Item" <<
+			setw(10) << "Num" <<
+			setw(10) << "Weight" <<
+			setw(10) << "Price" <<
+			"Date" << endl << endl;
+}
+
+
+//// print_stock_row ///////////////////////////////////////////////////
+// Print out a row of data from the stock table, in a format compatible
+// with the header printed out in the previous function.
+
+void
+print_stock_row(const mysqlpp::sql_char& item, mysqlpp::sql_bigint num,
+		mysqlpp::sql_double weight, mysqlpp::sql_decimal price,
+		const mysqlpp::sql_date& date)
+{
+	cout << setw(30) << item << ' ' <<
+			setw(9) << num << ' ' <<
+			setw(9) << weight << ' ' <<
+			setw(9) << price << ' ' <<
+			date << endl;
+}
+
+
+//// print_stock_row ///////////////////////////////////////////////////
+// Take a Row from the example 'stock' table, break it up into fields,
+// and call the above version of this function.
+
+void
+print_stock_row(const mysqlpp::Row& row)
+{
+	print_stock_row(string(row[0]), row[1], row[2], row[3], row[4]);
+}
+
+
+//// print_stock_rows //////////////////////////////////////////////////
+// Print out a number of rows from the example 'stock' table.
+
+void
+print_stock_rows(mysqlpp::StoreQueryResult& res)
+{
+	print_stock_header(res.size());
+
+	// Use the StoreQueryResult class's read-only random access iterator to walk
+	// through the query results.
+	mysqlpp::StoreQueryResult::iterator i;
+	for (i = res.begin(); i != res.end(); ++i) {
+		// Notice that a dereferenced result iterator can be converted
+		// to a Row object, which makes for easier element access.
+		print_stock_row(*i);
+	}
+}
+
+
+//// print_stock_table /////////////////////////////////////////////////
+// Simply retrieve and print the entire contents of the stock table.
+
+void
+print_stock_table(mysqlpp::Query& query)
+{
+	// Reset query object to its pristine state in case it's been used
+	// before by our caller for template queries.
+	query.reset();
+
+	// Build the query itself, and show it to the user
+	query << "select * from stock";
+	cout << "Query: " << query << endl;
+
+	// Execute it, and display the results
+	mysqlpp::StoreQueryResult res = query.store();
+	print_stock_rows(res);
+}

ADDED   examples/printdata.h
Index: examples/printdata.h
==================================================================
--- /dev/null
+++ examples/printdata.h
@@ -0,0 +1,42 @@
+/***********************************************************************
+ printdata.h - Declares utility routines for printing out data in
+    common forms, used by most of the example programs.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_PRINTDATA_H)
+#define MYSQLPP_PRINTDATA_H
+
+#include <mysql++.h>
+
+void print_stock_header(int rows);
+void print_stock_row(const mysqlpp::Row& r);
+void print_stock_row(const mysqlpp::sql_char& item,
+		mysqlpp::sql_bigint num, mysqlpp::sql_double weight,
+		mysqlpp::sql_decimal price, const mysqlpp::sql_date& date);
+void print_stock_rows(mysqlpp::StoreQueryResult& res);
+void print_stock_table(mysqlpp::Query& query);
+
+#endif // !defined(MYSQLPP_PRINTDATA_H)
+

DELETED examples/resetdb.cc
Index: examples/resetdb.cc
==================================================================
--- examples/resetdb.cc
+++ /dev/null
@@ -1,79 +0,0 @@
-
-#include <iostream>
-#include <sqlplus.hh>
-
-int main (int argc, char *argv[]) {
-  Connection connection(use_exceptions);
-  try { // the entire main block is one big try block;
-
-    if (argc == 1) connection.connect("");
-    else if (argc == 2) connection.connect("",argv[1]);
-    else if (argc == 3) connection.connect("",argv[1],argv[2]);
-    else if (argc <= 4) connection.connect("",argv[1],argv[2],argv[3]);
-    // create a new object and connect based on any (if any) arguments
-    // passed to main();
-    
-    try {
-      connection.select_db("mysql_cpp_data");
-    } catch (BadQuery er) {
-      // if it couldn't connect to the database assume that it doesn't exist
-      // and try created it.  If that does not work exit with an error.
-      connection.create_db("mysql_cpp_data");
-      connection.select_db("mysql_cpp_data");
-    }
-    
-    Query query = connection.query();  // create a new query object
-    
-    try { // ignore any errors here
-          // I hope to make this simpler soon
-      query.execute("drop table stock");
-    } catch (BadQuery er) {}
-    
-    query << "create table stock  (item char(20) not null, num smallint,"
-	  << "weight double, price double, sdate date)";
-    query.execute(RESET_QUERY);
-    // send the query to create the table and execute it.  The
-    // RESET_QUERY tells the query object to reset it self after
-    // execution
-    
-    query << "insert into %5:table values (%0q, %1q, %2, %3, %4q)";
-    query.parse();
-    // set up the template query I will use to insert the data.  The
-    // parse method call is important as it is what lets the query
-    // know that this is a template and not a literal string
-    
-    query.def["table"] = "stock";
-    // This is setting the parameter named table to stock.
-    
-    query.execute ("Hamburger Buns", 56, 1.25, 1.1, "1998-04-26");
-    query.execute ("Hotdogs' Buns"   ,65, 1.1 , 1.1, "1998-04-23");
-    query.execute ("Dinner Roles"  , 75,  .95, .97, "1998-05-25");
-    query.execute ("White Bread"   , 87, 1.5, 1.75, "1998-09-04");
-    // The last parameter "table" is not specified here.  Thus
-    // the default value for "table" is used which is "stock".
-
-  } catch (BadQuery er) { // handle any errors that may come up
-    cerr << "Error: " << er.error << endl;
-    return -1;
-  }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

ADDED   examples/resetdb.cpp
Index: examples/resetdb.cpp
==================================================================
--- /dev/null
+++ examples/resetdb.cpp
@@ -0,0 +1,214 @@
+/***********************************************************************
+ resetdb.cpp - (Re)initializes the example database, mysql_cpp_data.
+ 	You must run this at least once before running most of the other
+	examples, and it is helpful sometimes to run it again, as some of
+	the examples modify the table in this database.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
+ MySQL AB, and (c) 2004-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <mysql++.h>
+
+#include <iostream>
+
+using namespace std;
+
+
+// Pull in the sample database name from the cmdline module.
+extern const char* kpcSampleDatabase;
+
+
+// Convert a packed version number in the format used within MySQL++
+// to a printable string.
+static string
+version_str(int packed)
+{
+	char buf[9];
+	snprintf(buf, sizeof(buf), "%d.%d.%d",
+			(packed & 0xFF0000) >> 16,
+			(packed & 0x00FF00) >> 8,
+			(packed & 0x0000FF));
+	return buf;
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	// Ensure that we're not mixing library and header file versions.
+	// This is really easy to do if you have MySQL++ on your system and
+	// are trying to build a new version, and run the examples directly
+	// instead of through exrun.
+	if (mysqlpp::get_library_version() != MYSQLPP_HEADER_VERSION) {
+		cerr << "Version mismatch: library is v" <<
+				version_str(mysqlpp::get_library_version()) <<
+				", headers are v" <<
+				version_str(MYSQLPP_HEADER_VERSION) <<
+				".  Are you running this" << endl <<
+				"with exrun?  See README.examples." << endl;
+		return 1;
+	}
+	
+	// Connect to database server
+    const char *server = 0, *user = 0, *pass = "";
+	mysqlpp::Connection con;
+	try {
+		if (parse_command_line(argc, argv, 0, &server, &user, &pass)) {
+			extern bool dtest_mode;
+			if (dtest_mode) {
+				cout << "Connecting to database server..." << endl;
+			}
+			else {
+				cout << "Connecting to '" << 
+						(user ? user : "USERNAME") << "'@'" <<
+						(server ? server : "localhost") << "', with" <<
+						(pass[0] ? "" : "out") << " password..." << endl;
+			}
+			con.connect(0, server, user, pass);
+		}
+		else {
+			return 1;		// command line parsing failed
+		}
+	}
+	catch (exception& er) {
+		cerr << "Connection failed: " << er.what() << endl;
+		return 1;
+	}
+	
+	// Create new sample database, or re-create it.  We suppress
+	// exceptions, because it's not an error if DB doesn't yet exist.
+	bool new_db = false;
+	{
+		mysqlpp::NoExceptions ne(con);
+		mysqlpp::Query query = con.query();
+		if (con.select_db(kpcSampleDatabase)) {
+			// Toss old tables, ignoring errors because it would just
+			// mean the table doesn't exist, which doesn't matter.
+			cout << "Dropping existing sample data tables..." << endl;
+			query.exec("drop table stock");
+			query.exec("drop table images");
+			query.exec("drop table deadlock_test1");
+			query.exec("drop table deadlock_test2");
+		}
+		else {
+			// Database doesn't exist yet, so create and select it.
+			if (con.create_db(kpcSampleDatabase) &&
+					con.select_db(kpcSampleDatabase)) {
+				new_db = true;
+			}
+			else {
+				cerr << "Error creating DB: " << con.error() << endl;
+				return 1;
+			}
+		}
+	}
+
+	// Create sample data table within sample database.
+	try {
+		// Send the query to create the stock table and execute it.
+		cout << "Creating stock table..." << endl;
+		mysqlpp::Query query = con.query();
+		query << 
+				"CREATE TABLE stock (" <<
+				"  item CHAR(30) NOT NULL, " <<
+				"  num BIGINT NOT NULL, " <<
+				"  weight DOUBLE NOT NULL, " <<
+				"  price DECIMAL(6,2) NOT NULL, " <<
+				"  sdate DATE NOT NULL, " <<
+				"  description MEDIUMTEXT NULL) " <<
+				"ENGINE = InnoDB " <<
+				"CHARACTER SET utf8 COLLATE utf8_general_ci";
+		query.execute();
+
+		// Set up the template query to insert the data.  The parse()
+		// call tells the query object that this is a template and
+		// not a literal query string.
+		query << "insert into %6:table values " <<
+                "(%0q, %1q, %2, %3, %4q, %5q:desc)";
+		query.parse();
+
+		// Set a default for template query parameters "table" and "desc".
+		query.template_defaults["table"] = "stock";
+		query.template_defaults["desc"] = mysqlpp::null;
+
+		// Notice that we don't give a sixth parameter in these calls,
+		// so the default value of "stock" is used.  Also notice that
+		// the first row is a UTF-8 encoded Unicode string!  All you
+		// have to do to store Unicode data in recent versions of MySQL
+		// is use UTF-8 encoding.
+		cout << "Populating stock table..." << flush;
+		query.execute("NĆ¼rnberger Brats", 97, 1.5, 8.79, "2005-03-10");
+		query.execute("Pickle Relish", 87, 1.5, 1.75, "1998-09-04");
+		query.execute("Hot Mustard", 73, .95, .97, "1998-05-25",
+                "good American yellow mustard, not that European stuff");
+		query.execute("Hotdog Buns", 65, 1.1, 1.1, "1998-04-23");
+
+		// Test that above did what we wanted.
+		cout << "inserted " << con.count_rows("stock") << " rows." << endl;
+
+		// Now create empty images table, for testing BLOB and auto-
+		// increment column features.
+		cout << "Creating empty images table..." << endl;
+		query.reset();		// forget template query info
+		query << 
+				"CREATE TABLE images (" <<
+				"  id INT UNSIGNED NOT NULL AUTO_INCREMENT, " <<
+				"  data BLOB, " <<
+				"  PRIMARY KEY (id)" <<
+				")";
+		query.execute();
+
+		// Create the tables used by examples/deadlock.cpp
+		cout << "Creating deadlock testing tables..." << endl;
+		query.execute("CREATE TABLE deadlock_test1 (x INT) ENGINE=innodb");
+		query.execute("CREATE TABLE deadlock_test2 (x INT) ENGINE=innodb");
+		query.execute("INSERT INTO deadlock_test1 VALUES (1);");
+		query.execute("INSERT INTO deadlock_test2 VALUES (2);");
+
+		// Report success
+		cout << (new_db ? "Created" : "Reinitialized") <<
+				" sample database successfully." << endl;
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << endl << "Query error: " << er.what() << endl;
+		return 1;
+	}
+	catch (const mysqlpp::BadConversion& er) {
+		// Handle bad conversions
+		cerr << endl << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return 1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << endl << "Error: " << er.what() << endl;
+		return 1;
+	}
+
+	return 0;
+}

DELETED examples/simple1.cc
Index: examples/simple1.cc
==================================================================
--- examples/simple1.cc
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <iostream>
-#include <iomanip>
-#include <sqlplus.hh>
-
-int main() {
-  Connection con("mysql_cpp_data");
-  // The full format for the Connection constructor is
-  // Connection(cchar *db, cchar *host="", 
-  //            cchar *user="", cchar *passwd="") 
-  // You may need to specify some of them if the database is not on
-  // the local machine or you database username is not the same as your
-  // login name, etc..
-
-  Query query = con.query();
-  // This creates a query object that is bound to con.
-
-  query << "select * from stock";
-  // You can write to the query object like you would any other ostrem
-
-  Result res = query.store();
-  // Query::store() executes the query and returns the results
-
-  cout << "Query: " << query.preview() << endl;
-  // Query::preview() simply returns a string with the current query
-  // string in it.
-
-  cout << "Records Found: " << res.size() << endl << endl;
-  
-  Row row;
-  cout.setf(ios::left);
-  cout << setw(17) << "Item" 
-       << setw(4)  << "Num"
-       << setw(7)  << "Weight"
-       << setw(7)  << "Price" 
-       << "Date" << endl
-       << endl;
-  
-  Result::iterator i;
-  // The Result class has a read-only Random Access Iterator
-  for (i = res.begin(); i != res.end(); i++) {
-    row = *i;
-    cout << setw(17) << row[0] 
-	 << setw(4)  << row[1] 
-	 << setw(7)  << row["weight"]
-      // you can use either the index number or column name when
-      // retrieving the colume data as demonstrated above.
-	 << setw(7)  << row[3]
-	 << row[4] << endl;
-  }
-  return 0;
-}

ADDED   examples/simple1.cpp
Index: examples/simple1.cpp
==================================================================
--- /dev/null
+++ examples/simple1.cpp
@@ -0,0 +1,70 @@
+/***********************************************************************
+ simple1.cpp - Example showing the simplest way to get data from a MySQL
+    table with MySQL++.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <mysql++.h>
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	// Connect to the sample database.
+	mysqlpp::Connection conn(false);
+	if (conn.connect(db, server, user, pass)) {
+		// Retrieve a subset of the sample stock table set up by resetdb
+		// and display it.
+		mysqlpp::Query query = conn.query("select item from stock");
+		if (mysqlpp::StoreQueryResult res = query.store()) {
+			cout << "We have:" << endl;
+			for (size_t i = 0; i < res.num_rows(); ++i) {
+				cout << '\t' << res[i][0] << endl;
+			}
+		}
+		else {
+			cerr << "Failed to get item list: " << query.error() << endl;
+			return 1;
+		}
+
+		return 0;
+	}
+	else {
+		cerr << "DB connection failed: " << conn.error() << endl;
+		return 1;
+	}
+}

ADDED   examples/simple2.cpp
Index: examples/simple2.cpp
==================================================================
--- /dev/null
+++ examples/simple2.cpp
@@ -0,0 +1,85 @@
+/***********************************************************************
+ simple2.cpp - Retrieves the entire contents of the sample stock table
+ 	using a "store" query, and prints it out.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <mysql++.h>
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	// Connect to the sample database.
+	mysqlpp::Connection conn(false);
+	if (conn.connect(db, server, user, pass)) {
+		// Retrieve the sample stock table set up by resetdb
+		mysqlpp::Query query = conn.query("select * from stock");
+		mysqlpp::StoreQueryResult res = query.store();
+
+		// Display results
+		if (res) {
+			// Display header
+			cout.setf(ios::left);
+			cout << setw(31) << "Item" <<
+					setw(10) << "Num" <<
+					setw(10) << "Weight" <<
+					setw(10) << "Price" <<
+					"Date" << endl << endl;
+
+			// Get each row in result set, and print its contents
+			for (size_t i = 0; i < res.num_rows(); ++i) {
+				cout << setw(30) << res[i]["item"] << ' ' <<
+						setw(9) << res[i]["num"] << ' ' <<
+						setw(9) << res[i]["weight"] << ' ' <<
+						setw(9) << res[i]["price"] << ' ' <<
+						setw(9) << res[i]["sdate"] <<
+						endl;
+			}
+		}
+		else {
+			cerr << "Failed to get stock table: " << query.error() << endl;
+			return 1;
+		}
+
+		return 0;
+	}
+	else {
+		cerr << "DB connection failed: " << conn.error() << endl;
+		return 1;
+	}
+}

ADDED   examples/simple3.cpp
Index: examples/simple3.cpp
==================================================================
--- /dev/null
+++ examples/simple3.cpp
@@ -0,0 +1,92 @@
+/***********************************************************************
+ simple3.cpp - Example showing how to use the 'use' method of retrieving
+	a table, as opposed to the more common 'store' method illustrated
+	by the simple2 example.
+
+ Copyright (c) 2005-2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <mysql++.h>
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	// Connect to the sample database.
+	mysqlpp::Connection conn(false);
+	if (conn.connect(db, server, user, pass)) {
+		// Ask for all rows from the sample stock table and display
+		// them.  Unlike simple2 example, we retreive each row one at
+		// a time instead of storing the entire result set in memory
+		// and then iterating over it.
+		mysqlpp::Query query = conn.query("select * from stock");
+		if (mysqlpp::UseQueryResult res = query.use()) {
+			// Display header
+			cout.setf(ios::left);
+			cout << setw(31) << "Item" <<
+					setw(10) << "Num" <<
+					setw(10) << "Weight" <<
+					setw(10) << "Price" <<
+					"Date" << endl << endl;
+
+			// Get each row in result set, and print its contents
+			while (mysqlpp::Row row = res.fetch_row()) {
+				cout << setw(30) << row["item"] << ' ' <<
+						setw(9) << row["num"] << ' ' <<
+						setw(9) << row["weight"] << ' ' <<
+						setw(9) << row["price"] << ' ' <<
+						setw(9) << row["sdate"] <<
+						endl;
+			}
+
+			// Check for error: can't distinguish "end of results" and
+			// error cases in return from fetch_row() otherwise.
+			if (conn.errnum()) {
+				cerr << "Error received in fetching a row: " <<
+						conn.error() << endl;
+				return 1;
+			}
+			return 0;
+		}
+		else {
+			cerr << "Failed to get stock item: " << query.error() << endl;
+			return 1;
+		}
+	}
+	else {
+		cerr << "DB connection failed: " << conn.error() << endl;
+		return 1;
+	}
+}

DELETED examples/sinisa_ex.cc
Index: examples/sinisa_ex.cc
==================================================================
--- examples/sinisa_ex.cc
+++ /dev/null
@@ -1,96 +0,0 @@
-#include <vector>
-#include <string>
-vector<string> yy;
-#include <iostream>
-#include <iomanip>
-#include <mysql++>
-
-int main() {
-  Connection con(use_exceptions);
-	try {
-	con.real_connect ("","localhost","root","",3306,(int)0,60,NULL);
-					
-	cout << con.clinet_info() << endl << endl;
-  Query query = con.query();
-
-  query << "show databases";
-
-  Result res = query.store();
-
-  cout << "Query: " << query.preview() << endl;
-
-  cout << "Records Found: " << res.size() << endl << endl;
-  
-  Row row;
-  cout.setf(ios::left);
-  cout << setw(17) << "Databases"  << endl << endl;
-  
-  Result::iterator i;
-  for (i = res.begin(); i != res.end(); i++) {
-    row = *i;
-    cout << setw(17) << row[0]  << endl;
-  }
-	char database [] = "mysql";
-  con.select_db (database);
-
-  query << "show tables";
-
-  res = query.store();
-
-  cout << "Query: " << query.preview() << endl;
-
-  cout << "Records Found: " << res.size() << endl << endl;
-  
-  cout.setf(ios::left);
-  cout << setw(17) << "Tables"  << endl << endl;
-			
-  for (i = res.begin(); i != res.end(); i++) {
-    row = *i;
-		string xx(row[0]);
-    cout << setw(17) << row[0]  << endl;
-		yy.insert(yy.end(),xx);
-  }
-	for (unsigned int j = 0; j < yy.size();j++) {
-		query << "describe " << yy[j] << "";
-		cout << query.preview() << endl << endl;
-		res = query.store();
-		unsigned int columns = res.num_fields(), counter;
-		cout << setw(15) << endl;
-		for (counter = 0; counter < columns; counter++) {
-			cout << setw(15) << res.names(counter) << "  ";
-		}
-		cout << endl << endl;
-		for (i = res.begin(); i!=res.end();i++) {
-			row = *i;
-			for (counter = 0; counter < columns; counter++)  {
-				cout << row[counter] << "  ";
-			}
-			cout << endl;
-		}
-	}
-		query << "select * from user";
-		res  =  query.store(); int columns =  res.num_fields();
-		cout << query.preview() << endl << endl;
-		cout << "fields = " << res.num_fields() << "rows = " << res.size() << endl;
-		for (i = res.begin(); i!=res.end();i++) {
-			row = *i;
-			for (int counter = 0; counter < columns; counter++)  {
-				cout << row[counter] << "  ";
-			}
-			cout << endl;
-		}
-  } catch (BadQuery er){ // handle any connection 
-                         // or query errors that may come up
-    cerr << "Error: " << er.error << " " << con.errnum() << endl;
-    return -1;
-
-  } catch (BadConversion er) {
-    // we still need to cache bad conversions incase something goes 
-    // wrong when the data is converted into stock
-    cerr << "Error: Tried to convert \"" << er.data << "\" to a \""
-	 << er.type_name << "\"." << endl;
-    return -1;
-  }
-
-}
-

ADDED   examples/ssqls1.cpp
Index: examples/ssqls1.cpp
==================================================================
--- /dev/null
+++ examples/ssqls1.cpp
@@ -0,0 +1,89 @@
+/***********************************************************************
+ ssqls1.cpp - Example that produces the same results as simple1, but it
+ 	uses a Specialized SQL Structure to store the results instead of a
+	MySQL++ Result object.
+ 
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+#include "stock.h"
+
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {						
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Retrieve a subset of the stock table's columns, and store
+		// the data in a vector of 'stock' SSQLS structures.  See the
+		// user manual for the consequences arising from this quiet
+		// ability to store a subset of the table in the stock SSQLS.
+		mysqlpp::Query query = con.query("select item,description from stock");
+		vector<stock> res;
+		query.storein(res);
+
+		// Display the items
+		cout << "We have:" << endl;
+		vector<stock>::iterator it;
+		for (it = res.begin(); it != res.end(); ++it) {
+			cout << '\t' << it->item;
+			if (it->description != mysqlpp::null) {
+				cout << " (" << it->description << ")";
+			}
+			cout << endl;
+		}
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::BadConversion& er) {
+		// Handle bad conversions; e.g. type mismatch populating 'stock'
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/ssqls2.cpp
Index: examples/ssqls2.cpp
==================================================================
--- /dev/null
+++ examples/ssqls2.cpp
@@ -0,0 +1,88 @@
+/***********************************************************************
+ ssqls2.cpp - Example showing how to insert a row using the Specialized
+ 	SQL Structures feature of MySQL++.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+#include "stock.h"
+
+#include <iostream>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Create and populate a stock object.  We could also have used
+		// the set() member, which takes the same parameters as this
+		// constructor.
+		stock row("Hot Dogs", 100, 1.5, 1.75,
+				mysqlpp::sql_date("1998-09-25"), mysqlpp::null);
+
+		// Form the query to insert the row into the stock table.
+		mysqlpp::Query query = con.query();
+		query.insert(row);
+
+		// Show the query about to be executed.
+		cout << "Query: " << query << endl;
+
+		// Execute the query.  We use execute() because INSERT doesn't
+		// return a result set.
+		query.execute();
+
+		// Retrieve and print out the new table contents.
+        print_stock_table(query);
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::BadConversion& er) {	
+		// Handle bad conversions
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/ssqls3.cpp
Index: examples/ssqls3.cpp
==================================================================
--- /dev/null
+++ examples/ssqls3.cpp
@@ -0,0 +1,108 @@
+/***********************************************************************
+ ssqls3.cpp - Example showing how to update an SQL row using the
+	Specialized SQL Structures feature of MySQL++.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+#include "stock.h"
+
+#include <iostream>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Build a query to retrieve the stock item that has Unicode
+		// characters encoded in UTF-8 form.
+		mysqlpp::Query query = con.query(
+				"select * from stock where item = \"NĆ¼rnberger Brats\"");
+
+		// Retrieve the row, throwing an exception if it fails.
+		mysqlpp::StoreQueryResult res = query.store();
+		if (res.empty()) {
+			throw mysqlpp::BadQuery("UTF-8 bratwurst item not found in "
+					"table, run resetdb");
+		}
+
+		// Because there should only be one row in the result set,
+		// there's no point in storing the result in an STL container.
+		// We can store the first row directly into a stock structure
+		// because one of an SSQLS's constructors takes a Row object.
+		stock row = res[0];
+
+		// Create a copy so that the replace query knows what the
+		// original values are.
+		stock orig_row = row;
+
+		// Change the stock object's item to use only 7-bit ASCII, and
+		// to deliberately be wider than normal column widths printed
+		// by print_stock_table().
+		row.item = "Nuerenberger Bratwurst";
+
+		// Form the query to replace the row in the stock table.
+		query.update(orig_row, row);
+
+		// Show the query about to be executed.
+		cout << "Query: " << query << endl;
+
+		// Run the query with execute(), since UPDATE doesn't return a
+		// result set.
+		query.execute();
+
+		// Retrieve and print out the new table contents.
+        print_stock_table(query);
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::BadConversion& er) {
+		// Handle bad conversions
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/ssqls4.cpp
Index: examples/ssqls4.cpp
==================================================================
--- /dev/null
+++ examples/ssqls4.cpp
@@ -0,0 +1,100 @@
+/***********************************************************************
+ ssqls4.cpp - Example very similar to ssqls1.cpp, except that it
+	stores its result set in an STL set container.  This demonstrates
+	how one can manipulate MySQL++ result sets in a very natural C++
+	style.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+#include "stock.h"
+
+#include <iostream>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Retrieve all rows from the stock table and put them in an
+		// STL set.  Notice that this works just as well as storing them
+		// in a vector, which we did in ssqls1.cpp.  It works because
+		// SSQLS objects are less-than comparable.
+		mysqlpp::Query query = con.query("select * from stock");
+		set<stock> res;
+		query.storein(res);
+
+		// Display the result set.  Since it is an STL set and we set up
+		// the SSQLS to compare based on the item column, the rows will
+		// be sorted by item.
+		print_stock_header(res.size());
+		set<stock>::iterator it;
+		cout.precision(3);
+		for (it = res.begin(); it != res.end(); ++it) {
+			print_stock_row(it->item.c_str(), it->num, it->weight,
+					it->price, it->sdate);
+		}
+
+		// Use set's find method to look up a stock item by item name.
+		// This also uses the SSQLS comparison setup.
+		it = res.find(stock("Hotdog Buns"));
+		if (it != res.end()) {
+			cout << endl << "Currently " << it->num <<
+					" hotdog buns in stock." << endl;
+		}
+		else {
+			cout << endl << "Sorry, no hotdog buns in stock." << endl;
+		}
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::BadConversion& er) {
+		// Handle bad conversions
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/ssqls5.cpp
Index: examples/ssqls5.cpp
==================================================================
--- /dev/null
+++ examples/ssqls5.cpp
@@ -0,0 +1,85 @@
+/***********************************************************************
+ ssqls5.cpp - Example showing how to use the equal_list() member of
+ 	some SSQLS types to build SELECT queries with custom WHERE clauses.
+ 
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, (c)
+ 2004-2008 by Educational Technology Resources, Inc., and (c) 2005 by
+ Chris Frey.  Others may also hold copyrights on code in this file.
+ See the CREDITS file in the top directory of the distribution for
+ details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+#include "stock.h"
+
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Get all the rows in the stock table.
+		mysqlpp::Query query = con.query("select * from stock");
+		vector<stock> res;
+		query.storein(res);
+
+		if (res.size() > 0) {
+			// Build a select query using the data from the first row
+			// returned by our previous query.
+			query << "select * from stock where " <<
+					res[0].equal_list(" and ", stock_weight, stock_price);
+
+			// Display the finished query.
+			cout << "Custom query:\n" << query << endl;
+		}
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::BadConversion& er) {
+		// Handle bad conversions
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/stock.h
Index: examples/stock.h
==================================================================
--- /dev/null
+++ examples/stock.h
@@ -0,0 +1,47 @@
+/***********************************************************************
+ stock.h - Declares the stock SSQLS used by several of the examples.
+ 
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+#include <ssqls.h>
+
+// The following is calling a very complex macro which will create
+// "struct stock", which has the member variables:
+//
+//   sql_char item;
+//   ...
+//   Null<sql_mediumtext> description;
+//
+// plus methods to help populate the class from a MySQL row.  See the
+// SSQLS sections in the user manual for further details.
+sql_create_6(stock,
+	1, 6, // The meaning of these values is covered in the user manual
+	mysqlpp::sql_char, item,
+	mysqlpp::sql_bigint, num,
+	mysqlpp::sql_double, weight,
+	mysqlpp::sql_double, price,
+	mysqlpp::sql_date, sdate,
+	mysqlpp::Null<mysqlpp::sql_mediumtext>, description)
+

ADDED   examples/store_if.cpp
Index: examples/store_if.cpp
==================================================================
--- /dev/null
+++ examples/store_if.cpp
@@ -0,0 +1,103 @@
+/***********************************************************************
+ store_if.cpp - Demonstrates Query::store_if(), showing only the rows
+	from the sample table with prime quantities.  This isn't intended
+	to be useful, only to show how you can do result set filtering that
+	outstrips the power of SQL.
+
+ Copyright (c) 2005-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+#include "stock.h"
+
+#include <mysql++.h>
+
+#include <iostream>
+
+#include <math.h>
+
+
+// Define a functor for testing primality.
+struct is_prime
+{
+	bool operator()(const stock& s)
+	{
+		if ((s.num == 2) || (s.num == 3)) {
+			return true;	// 2 and 3 are trivial cases
+		}
+		else if ((s.num < 2) || ((s.num % 2) == 0)) {
+			return false;	// can't be prime if < 2 or even
+		}
+		else {
+			// The only possibility left is that it's divisible by an
+			// odd number that's less than or equal to its square root.
+			for (int i = 3; i <= sqrt(double(s.num)); i += 2) {
+				if ((s.num % i) == 0) {
+					return false;
+				}
+			}
+			return true;
+		}
+	}
+};
+
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Collect the stock items with prime quantities
+		std::vector<stock> results;
+		mysqlpp::Query query = con.query();
+		query.store_if(results, stock(), is_prime());
+
+		// Show the results
+		print_stock_header(results.size());
+		std::vector<stock>::const_iterator it;
+		for (it = results.begin(); it != results.end(); ++it) {
+			print_stock_row(it->item.c_str(), it->num, it->weight,
+					it->price, it->sdate);
+		}
+	}
+	catch (const mysqlpp::BadQuery& e) {
+		// Something went wrong with the SQL query.
+		std::cerr << "Query failed: " << e.what() << std::endl;
+		return 1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		std::cerr << "Error: " << er.what() << std::endl;
+		return 1;
+	}
+
+	return 0;
+}

ADDED   examples/threads.h
Index: examples/threads.h
==================================================================
--- /dev/null
+++ examples/threads.h
@@ -0,0 +1,60 @@
+/***********************************************************************
+ threads.h - Abstracts away the differences between POSIX threads and
+	Windows native threads.  Used by the cpool example only; we could
+	keep this code inline there, but it's really just unimportant
+	details.
+
+ Copyright (c) 2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_THREADS_H)
+#define MYSQLPP_THREADS_H
+
+#include <mysql++.h>
+
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+#	define HAVE_THREADS
+#	define CALLBACK_SPECIFIER WINAPI
+	typedef DWORD thread_return_t;
+	typedef LPVOID thread_arg_t;
+	static int create_thread(LPTHREAD_START_ROUTINE worker, thread_arg_t arg)
+	{
+		return CreateThread(0, 0, worker, arg, 0, 0) ? 0 : GetLastError();
+	}
+	static void sleep(int s) { Sleep(s * 1000); }
+#else
+#	include "../config.h"
+#	if defined(HAVE_PTHREAD)
+#		define HAVE_THREADS
+#		define CALLBACK_SPECIFIER
+		typedef void* thread_return_t;
+		typedef void* thread_arg_t;
+		static int create_thread(thread_return_t(*worker)(thread_arg_t),
+				thread_arg_t arg)
+		{
+			pthread_t pt;
+			return pthread_create(&pt, 0, worker, arg);
+		}
+#	endif
+#endif
+
+#endif // !defined(MYSQLPP_THREADS_H)

ADDED   examples/tquery1.cpp
Index: examples/tquery1.cpp
==================================================================
--- /dev/null
+++ examples/tquery1.cpp
@@ -0,0 +1,92 @@
+/***********************************************************************
+ tquery1.cpp - Example similar to ssqls3.cpp, except that it uses
+	template queries instead of SSQLS.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <iostream>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Build a template query to retrieve a stock item given by
+		// item name.
+		mysqlpp::Query query = con.query(
+				"select * from stock where item = %0q");
+		query.parse();
+
+		// Retrieve an item added by resetdb; it won't be there if
+		// tquery* or ssqls3 is run since resetdb.
+		mysqlpp::StoreQueryResult res1 = query.store("NĆ¼rnberger Brats");
+		if (res1.empty()) {
+			throw mysqlpp::BadQuery("UTF-8 bratwurst item not found in "
+					"table, run resetdb");
+		}
+
+		// Replace the proper German name with a 7-bit ASCII
+		// approximation using a different template query.
+		query.reset();		// forget previous template query data
+		query << "update stock set item = %0q where item = %1q";
+		query.parse();
+		mysqlpp::SimpleResult res2 = query.execute("Nuerenberger Bratwurst",
+				res1[0][0].c_str());
+
+		// Print the new table contents.
+		print_stock_table(query);
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::BadConversion& er) {
+		// Handle bad conversions
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/tquery2.cpp
Index: examples/tquery2.cpp
==================================================================
--- /dev/null
+++ examples/tquery2.cpp
@@ -0,0 +1,98 @@
+/***********************************************************************
+ tquery2.cpp - Same as tquery1.cpp, except that it passes the template
+    query parameters in a SQLQueryParms object, instead of separately.
+	This is useful when the calling code doesn't know in advance how
+	many parameters there will be.  This is most likely because the
+	templates are coming from somewhere else, or being generated.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <iostream>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Build a template query to retrieve a stock item given by
+		// item name.
+		mysqlpp::Query query = con.query(
+				"select * from stock where item = %0q");
+		query.parse();
+
+		// Retrieve an item added by resetdb; it won't be there if
+		// tquery* or ssqls3 is run since resetdb.
+		mysqlpp::SQLQueryParms sqp;
+		sqp << "NĆ¼rnberger Brats";
+		mysqlpp::StoreQueryResult res1 = query.store(sqp);
+		if (res1.empty()) {
+			throw mysqlpp::BadQuery("UTF-8 bratwurst item not found in "
+					"table, run resetdb");
+		}
+
+		// Replace the proper German name with a 7-bit ASCII
+		// approximation using a different template query.
+		query.reset();		// forget previous template query info
+		query << "update stock set item = %0q where item = %1q";
+		query.parse();
+		sqp.clear();
+		sqp << "Nuerenberger Bratwurst" << res1[0][0].c_str();
+		mysqlpp::SimpleResult res2 = query.execute(sqp);
+
+		// Print the new table contents.
+		print_stock_table(query);
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::BadConversion& er) {
+		// Handle bad conversions
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

ADDED   examples/tquery3.cpp
Index: examples/tquery3.cpp
==================================================================
--- /dev/null
+++ examples/tquery3.cpp
@@ -0,0 +1,82 @@
+/***********************************************************************
+ tquery3.cpp - Similar to tquery1.cpp but uses unquoted parameters.
+    It's here more for code test coverage than because it shows
+    something interesting.  We've historically had a problem with
+    tqueries with just one parameter; we cover the quoted case in
+    resetdb and the other tquery examples, so we get the unquoted
+    one here.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+
+#include <iostream>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Build a template query to retrieve item names for stock
+        // entries with a quantity over some threshold.
+		mysqlpp::Query query = con.query(
+				"select item from stock where num > %0");
+		query.parse();
+
+		// Get a list of things we have lots of in stock
+		if (mysqlpp::StoreQueryResult res = query.store(80)) {
+            cout << "Stuff we have a lot of in stock:" << endl;
+			for (size_t i = 0; i < res.num_rows(); ++i) {
+				cout << '\t' << res[i]["item"] << endl;
+			}
+		}
+		else {
+			cerr << "Failed to get item list: " << query.error() << endl;
+			return 1;
+		}
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return 2;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return 2;
+	}
+
+	return 0;
+}

ADDED   examples/transaction.cpp
Index: examples/transaction.cpp
==================================================================
--- /dev/null
+++ examples/transaction.cpp
@@ -0,0 +1,107 @@
+/***********************************************************************
+ transaction.cpp - Example showing how to use the transaction support in
+ 	MySQL++ v2.1 and up.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cmdline.h"
+#include "printdata.h"
+#include "stock.h"
+
+#include <iostream>
+
+using namespace std;
+
+int
+main(int argc, char *argv[])
+{
+	// Get database access parameters from command line
+    const char* db = 0, *server = 0, *user = 0, *pass = "";
+	if (!parse_command_line(argc, argv, &db, &server, &user, &pass)) {
+		return 1;
+	}
+
+	try {
+		// Establish the connection to the database server.
+		mysqlpp::Connection con(db, server, user, pass);
+
+		// Show initial state
+		mysqlpp::Query query = con.query();
+		cout << "Initial state of stock table:" << endl;
+		print_stock_table(query);
+
+		// Insert a few rows in a single transaction set
+		{
+			mysqlpp::Transaction trans(con);
+
+			stock row("Sauerkraut", 42, 1.2, 0.75,
+					mysqlpp::sql_date("2006-03-06"), mysqlpp::null);
+			query.insert(row);
+			query.execute();
+
+			cout << "\nRow inserted, but not committed." << endl;
+			cout << "Verify this with another program (e.g. simple1), "
+					"then hit Enter." << endl;
+			getchar();
+
+			cout << "\nCommitting transaction gives us:" << endl;
+			trans.commit();
+			print_stock_table(query);
+		}
+			
+		// Now let's test auto-rollback
+		{
+			mysqlpp::Transaction trans(con);
+			cout << "\nNow adding catsup to the database..." << endl;
+
+			stock row("Catsup", 3, 3.9, 2.99,
+					mysqlpp::sql_date("2006-03-06"), mysqlpp::null);
+			query.insert(row);
+			query.execute();
+		}
+		cout << "\nNo, yuck! We don't like catsup. Rolling it back:" <<
+				endl;
+		print_stock_table(query);
+			
+	}
+	catch (const mysqlpp::BadQuery& er) {
+		// Handle any query errors
+		cerr << "Query error: " << er.what() << endl;
+		return -1;
+	}
+	catch (const mysqlpp::BadConversion& er) {	
+		// Handle bad conversions
+		cerr << "Conversion error: " << er.what() << endl <<
+				"\tretrieved data size: " << er.retrieved <<
+				", actual size: " << er.actual_size << endl;
+		return -1;
+	}
+	catch (const mysqlpp::Exception& er) {
+		// Catch-all for any other MySQL++ exceptions
+		cerr << "Error: " << er.what() << endl;
+		return -1;
+	}
+
+	return 0;
+}

DELETED examples/util.cc
Index: examples/util.cc
==================================================================
--- examples/util.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-#include <iostream>
-#include <iomanip>
-#include "util.hh"
-
-void print_stock_table(Query& query) {
-  query.reset();
-  query << "select * from stock";
-  // You can write to the query object like you would any other ostrem
-
-  Result res = query.store();
-  // Query::store() executes the query and returns the results
-
-  cout << "Query: " << query.preview() << endl;
-  // Query::preview() simply returns a string with the current query
-  // string in it.
-
-  cout << "Records Found: " << res.size() << endl << endl;
-  
-  Row row;
-  cout.setf(ios::left);
-  cout << setw(17) << "Item" 
-       << setw(4)  << "Num"
-       << setw(7)  << "Weight"
-       << setw(7)  << "Price" 
-       << "Date" << endl
-       << endl;
-  
-  Result::iterator i;
-  // The Result class has a read-only Random Access Iterator
-  for (i = res.begin(); i != res.end(); i++) {
-    row = *i;
-    cout << setw(17) << row[0] 
-	 << setw(4)  << row[1] 
-	 << setw(7)  << row["weight"]
-      // you can use either the index number or column name when
-      // retrieving the colume data as demonstrated above.
-	 << setw(7)  << row[3]
-	 << row[4] << endl;
-  }
-}

DELETED examples/util.hh
Index: examples/util.hh
==================================================================
--- examples/util.hh
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef _util_hh_
-#define _util_hh_
-
-#include <sqlplus.hh>
-
-void print_stock_table(Query& query);
-
-#endif

ADDED   examples/vstudio/mfc/mfc.cpp
Index: examples/vstudio/mfc/mfc.cpp
==================================================================
--- /dev/null
+++ examples/vstudio/mfc/mfc.cpp
@@ -0,0 +1,54 @@
+/***********************************************************************
+ mfc.cpp - Skeletal main module of the MySQL++ MFC example program.
+	Nothing interesting to see here.  Move along to mfc_dlg.cpp, folks.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others 
+ may also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "stdafx.h"
+#include "mfc.h"
+#include "mfc_dlg.h"
+
+CApp gApplication;
+
+BOOL CApp::InitInstance()
+{
+	// Set up Windows commomn controls
+	INITCOMMONCONTROLSEX InitCtrls;
+	InitCtrls.dwSize = sizeof(InitCtrls);
+	InitCtrls.dwICC = ICC_WIN95_CLASSES;
+	InitCommonControlsEx(&InitCtrls);
+
+	CWinApp::InitInstance();
+
+	// Initialize Winsock for MySQL communication, start GUI
+	if (AfxSocketInit()) {
+		CExampleDlg dlg;
+		m_pMainWnd = &dlg;
+		dlg.DoModal();
+	}
+	else {
+		AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
+	}
+
+	return FALSE;
+}

ADDED   examples/vstudio/mfc/mfc.h
Index: examples/vstudio/mfc/mfc.h
==================================================================
--- /dev/null
+++ examples/vstudio/mfc/mfc.h
@@ -0,0 +1,34 @@
+/***********************************************************************
+ mfc.cpp - Declares the MFC application object.  Nothing interesting to
+	see here.  Move along to mfc_dlg.cpp, folks.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others 
+ may also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#pragma once
+
+class CApp : public CWinApp
+{
+public:
+	CApp() { }
+	virtual BOOL InitInstance();
+};

ADDED   examples/vstudio/mfc/mfc.rc
Index: examples/vstudio/mfc/mfc.rc
==================================================================
--- /dev/null
+++ examples/vstudio/mfc/mfc.rc
@@ -0,0 +1,135 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "#define _AFX_NO_SPLITTER_RESOURCES\r\n"
+    "#define _AFX_NO_OLE_RESOURCES\r\n"
+    "#define _AFX_NO_TRACKER_RESOURCES\r\n"
+    "#define _AFX_NO_PROPERTY_RESOURCES\r\n"
+    "\r\n"
+    "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n"
+    "LANGUAGE 9, 1\r\n"
+    "#pragma code_page(1252)\r\n"
+    "#include ""afxres.rc""     // Standard components\r\n"
+    "#endif\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_MFC_DIALOG DIALOGEX 0, 0, 210, 105
+STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_VISIBLE | WS_CAPTION
+EXSTYLE WS_EX_APPWINDOW
+CAPTION "MySQL++ MFC Example"
+FONT 8, "MS Shell Dlg", 0, 0, 0x1
+BEGIN
+    EDITTEXT        IDC_SERVER_EDIT,51,7,94,14,ES_AUTOHSCROLL
+    EDITTEXT        IDC_USER_EDIT,51,24,94,14,ES_AUTOHSCROLL
+    EDITTEXT        IDC_PASSWORD_EDIT,51,41,94,14,ES_PASSWORD | ES_AUTOHSCROLL
+    DEFPUSHBUTTON   "Connect!",IDC_CONNECT_BUTTON,153,7,50,14
+    PUSHBUTTON      "Close",IDCANCEL,153,25,50,16
+    LISTBOX         IDC_RESULTS_LIST,51,58,94,40,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_DISABLED | WS_VSCROLL
+    RTEXT           "Server:",IDC_STATIC,7,7,40,8
+    RTEXT           "User name:",IDC_STATIC,7,24,40,8
+    RTEXT           "Password:",IDC_STATIC,7,41,40,8
+    RTEXT           "Results:",IDC_STATIC,7,58,40,8
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO 
+BEGIN
+    IDD_MFC_DIALOG, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 203
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 98
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE 
+BEGIN
+    IDP_SOCKETS_INIT_FAILED "Windows sockets initialization failed."
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+#define _AFX_NO_SPLITTER_RESOURCES
+#define _AFX_NO_OLE_RESOURCES
+#define _AFX_NO_TRACKER_RESOURCES
+#define _AFX_NO_PROPERTY_RESOURCES
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+LANGUAGE 9, 1
+#pragma code_page(1252)
+#include "afxres.rc"     // Standard components
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

ADDED   examples/vstudio/mfc/mfc_dlg.cpp
Index: examples/vstudio/mfc/mfc_dlg.cpp
==================================================================
--- /dev/null
+++ examples/vstudio/mfc/mfc_dlg.cpp
@@ -0,0 +1,275 @@
+/***********************************************************************
+ mfc_dlg.cpp - Defines the dialog box behavior for the MySQL++ MFC
+	example.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others 
+ may also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "stdafx.h"
+#include "mfc_dlg.h"
+
+#include <mysql++.h>
+
+BEGIN_MESSAGE_MAP(CExampleDlg, CDialog)
+	ON_BN_CLICKED(IDC_CONNECT_BUTTON, &CExampleDlg::OnBnClickedConnectButton)
+END_MESSAGE_MAP()
+
+
+//// ctor //////////////////////////////////////////////////////////////
+
+CExampleDlg::CExampleDlg(CWnd* pParent) :
+CDialog(IDD_MFC_DIALOG, pParent)
+{
+	LoadDefaults();
+}
+
+
+//// AddMessage ////////////////////////////////////////////////////////
+// Inserts the given string at the end of the list box we're using for
+// output to the user.
+
+void 
+CExampleDlg::AddMessage(LPCTSTR pcMessage)
+{
+	ResultsList.InsertString(-1, pcMessage);
+}
+
+
+//// DoDataExchange ////////////////////////////////////////////////////
+// Transfer data from the controls into our member variables
+
+void
+CExampleDlg::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	DDX_Text(pDX, IDC_SERVER_EDIT, sServerAddress);
+	DDX_Text(pDX, IDC_USER_EDIT, sUserName);
+	DDX_Text(pDX, IDC_PASSWORD_EDIT, sPassword);
+	DDX_Control(pDX, IDC_RESULTS_LIST, ResultsList);
+}
+
+
+//// LoadDefaults //////////////////////////////////////////////////////
+// Load default input values from registry, if they exist.
+
+void
+CExampleDlg::LoadDefaults()
+{
+	HKEY key = OpenSettingsRegistryKey();
+	if (key) {
+		TCHAR acSetting[100];
+		if (LoadSetting(key, _T("user"), acSetting, sizeof(acSetting))) {
+			sUserName = acSetting;
+		}
+		if (LoadSetting(key, _T("server"), acSetting, sizeof(acSetting))) {
+			sServerAddress = acSetting;
+		}
+		RegCloseKey(key);
+	}
+
+	if (sUserName.IsEmpty()) {
+		TCHAR acUserName[100];
+		DWORD nBufferSize = sizeof(acUserName);
+		if (GetUserName(acUserName, &nBufferSize)) {
+			sUserName = acUserName;
+		}
+	}
+	if (sServerAddress.IsEmpty()) {
+		sServerAddress = _T("localhost");
+	}
+}
+
+
+//// LoadSetting ///////////////////////////////////////////////////////
+// Loads up the value of the named registry value underneath the given
+// key and returns it in pcValue.
+
+bool
+CExampleDlg::LoadSetting(HKEY key, LPCTSTR pcName, LPTSTR pcValue,
+		DWORD nValueSize)
+{
+	return RegQueryValueEx(key, pcName, 0, 0, LPBYTE(pcValue),
+			&nValueSize) == ERROR_SUCCESS;
+}
+
+
+//// OnBnClickedConnectButton //////////////////////////////////////////
+// This is essentially the same thing as examples/simple1.cpp
+
+void
+CExampleDlg::OnBnClickedConnectButton()
+{
+	WCHAR awcTempBuf[100];
+	const int kTempBufSize = sizeof(awcTempBuf) / sizeof(awcTempBuf[0]);
+
+	// Pull user input into our member variables
+	UpdateData(TRUE);
+
+	// Clear out the results list, in case this isn't the first time
+	// we've come in here.
+	ResultsList.ResetContent();
+
+	// Translate the Unicode text we get from the UI into the UTF-8 form
+	// that MySQL wants.
+	const int kInputBufSize = 100;
+	char acServerAddress[kInputBufSize];
+	char acUserName[kInputBufSize];
+	char acPassword[kInputBufSize];
+	ToUTF8(acServerAddress, kInputBufSize, sServerAddress);
+	ToUTF8(acUserName, kInputBufSize, sUserName);
+	ToUTF8(acPassword, kInputBufSize, sPassword);
+
+	// Connect to the sample database.
+	mysqlpp::Connection con(false);
+	if (!con.connect("mysql_cpp_data", acServerAddress, acUserName,
+			acPassword)) {
+		AddMessage(_T("Failed to connect to server:"));
+		if (ToUCS2(awcTempBuf, kTempBufSize, con.error())) {
+			AddMessage(awcTempBuf);
+		}
+		return;
+	}
+
+	// Retrieve a subset of the sample stock table set up by resetdb
+	mysqlpp::Query query = con.query();
+	query << "select item from stock";
+	mysqlpp::StoreQueryResult res = query.store();
+
+	if (res) {
+		// Display the result set
+		mysqlpp::Row row;
+		for (mysqlpp::Row::size_type i = 0; row = res.at(i); ++i) {
+			if (ToUCS2(awcTempBuf, kTempBufSize, row.at(0))) {
+				AddMessage(awcTempBuf);
+			}
+		}
+
+		// Retreive was successful, so save user inputs now
+		SaveInputs();
+	}
+	else {
+		// Retreive failed
+		AddMessage(_T("Failed to get item list:"));
+		if (ToUCS2(awcTempBuf, kTempBufSize, query.error())) {
+			AddMessage(awcTempBuf);
+		}
+	}
+}
+
+
+//// OpenSettingsRegistryKey ///////////////////////////////////////////
+
+HKEY
+CExampleDlg::OpenSettingsRegistryKey()
+{
+	HKEY key1, key2;
+	if ((RegOpenKey(HKEY_CURRENT_USER, _T("Software"), &key1) ==
+			ERROR_SUCCESS) && (RegCreateKey(key1,
+			_T("MySQL++ Examples"), &key2) == ERROR_SUCCESS)) {
+		RegCloseKey(key1);
+		return key2;
+	}
+	else {
+		return 0;
+	}
+}
+
+
+//// SaveInputs ////////////////////////////////////////////////////////
+// Saves the input fields' values to the registry, except for the
+// password field.
+
+bool
+CExampleDlg::SaveInputs()
+{
+	HKEY key = OpenSettingsRegistryKey();
+	if (key) {
+		SaveSetting(key, _T("user"), sUserName);
+		SaveSetting(key, _T("server"), sServerAddress);
+		RegCloseKey(key);
+		return true;
+	}
+	else {
+		return false;
+	}
+}
+
+
+//// SaveSetting ///////////////////////////////////////////////////////
+// Saves the given value as a named entry under the given registry key.
+
+bool
+CExampleDlg::SaveSetting(HKEY key, LPCTSTR pcName, LPCTSTR pcValue)
+{
+	DWORD nBytes = DWORD(sizeof(TCHAR) * (_tcslen(pcValue) + 1));
+	return RegSetValueEx(key, pcName, 0, REG_SZ, LPBYTE(pcValue),
+			nBytes) == ERROR_SUCCESS;
+}
+
+
+//// ToUCS2 ////////////////////////////////////////////////////////////
+// Convert a C string in UTF-8 format to UCS-2 format.
+
+bool
+CExampleDlg::ToUCS2(LPTSTR pcOut, int nOutLen, const char* kpcIn)
+{
+	if (strlen(kpcIn) > 0) {
+		// Do the conversion normally
+		return MultiByteToWideChar(CP_UTF8, 0, kpcIn, -1, pcOut,
+				nOutLen) > 0;
+	}
+	else if (nOutLen > 1) {
+		// Can't distinguish no bytes copied from an error, so handle
+		// an empty input string as a special case.
+		_tccpy(pcOut, _T(""));
+		return true;
+	}
+	else {
+		// Not enough room to do anything!
+		return false;
+	}
+}
+
+
+//// ToUTF8 ////////////////////////////////////////////////////////////
+// Convert a UCS-2 multibyte string to the UTF-8 format required by
+// MySQL, and thus MySQL++.
+
+bool
+CExampleDlg::ToUTF8(char* pcOut, int nOutLen, LPCWSTR kpcIn)
+{
+	if (_tcslen(kpcIn) > 0) {
+		// Do the conversion normally
+		return WideCharToMultiByte(CP_UTF8, 0, kpcIn, -1, pcOut,
+				nOutLen, 0, 0) > 0;
+	}
+	else if (nOutLen > 0) {
+		// Can't distinguish no bytes copied from an error, so handle
+		// an empty input string as a special case.
+		*pcOut = '\0';
+		return true;
+	}
+	else {
+		// Not enough room to do anything!
+		return false;
+	}
+}

ADDED   examples/vstudio/mfc/mfc_dlg.h
Index: examples/vstudio/mfc/mfc_dlg.h
==================================================================
--- /dev/null
+++ examples/vstudio/mfc/mfc_dlg.h
@@ -0,0 +1,58 @@
+/***********************************************************************
+ mfc_dlg.h - Declares the dialog class for the MySQL++ MFC example.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others 
+ may also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#pragma once
+#include "afxwin.h"
+#include "resource.h"
+
+class CExampleDlg : public CDialog
+{
+public:
+	//// Public interface
+	CExampleDlg(CWnd* pParent = 0);
+
+	//// Public data
+	CString sServerAddress;
+	CString sUserName;
+	CString sPassword;
+	CListBox ResultsList;
+
+protected:
+	//// Internal support functions
+	void AddMessage(LPCTSTR pcMessage);
+	void DoDataExchange(CDataExchange* pDX);
+	void LoadDefaults();
+	bool LoadSetting(HKEY key, LPCTSTR pcName, LPTSTR pcValue,
+			DWORD nValueSize);
+	HKEY OpenSettingsRegistryKey();
+	bool SaveInputs();
+	bool SaveSetting(HKEY key, LPCTSTR pcName, LPCTSTR pcValue);
+	bool ToUCS2(LPTSTR pcOut, int nOutLen, const char* kpcIn);
+	bool ToUTF8(char* pcOut, int nOutLen, LPCWSTR kpcIn);
+
+	//// Message map
+	afx_msg void OnBnClickedConnectButton();
+	DECLARE_MESSAGE_MAP()
+};

ADDED   examples/vstudio/mfc/resource.h
Index: examples/vstudio/mfc/resource.h
==================================================================
--- /dev/null
+++ examples/vstudio/mfc/resource.h
@@ -0,0 +1,22 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by mfc.rc
+//
+#define IDD_MFC_DIALOG                  102
+#define IDP_SOCKETS_INIT_FAILED         103
+#define IDC_SERVER_EDIT                 1000
+#define IDC_PASSWORD_EDIT               1001
+#define IDC_USER_EDIT                   1002
+#define IDC_RESULTS_LIST                1003
+#define IDC_CONNECT_BUTTON              1004
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        129
+#define _APS_NEXT_COMMAND_VALUE         32771
+#define _APS_NEXT_CONTROL_VALUE         1005
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

ADDED   examples/vstudio/mfc/stdafx.h
Index: examples/vstudio/mfc/stdafx.h
==================================================================
--- /dev/null
+++ examples/vstudio/mfc/stdafx.h
@@ -0,0 +1,54 @@
+/***********************************************************************
+ stdafx.h - Common include file to bring in MFC support and other
+	basics.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others 
+ may also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#pragma once
+
+#ifndef VC_EXTRALEAN
+#define VC_EXTRALEAN		// Exclude rarely-used stuff from Windows headers
+#endif
+
+// Modify the following defines if you have to target a platform prior to the ones specified below.
+// Refer to MSDN for the latest info on corresponding values for different platforms.
+#ifndef WINVER				// Allow use of features specific to Windows XP or later.
+#define WINVER 0x0501		// Change this to the appropriate value to target other versions of Windows.
+#endif
+
+#ifndef _WIN32_WINNT		// Allow use of features specific to Windows XP or later.                   
+#define _WIN32_WINNT 0x0501	// Change this to the appropriate value to target other versions of Windows.
+#endif						
+
+#ifndef _WIN32_WINDOWS		// Allow use of features specific to Windows 98 or later.
+#define _WIN32_WINDOWS 0x0410 // Change this to the appropriate value to target Windows Me or later.
+#endif
+
+// turns off MFC's hiding of some common and often safely ignored warning messages
+#define _AFX_ALL_WARNINGS
+
+#include <afxwin.h>         // MFC core and standard components
+#include <afxext.h>         // MFC extensions
+#include <afxcmn.h>			// MFC support for Windows Common Controls
+#include <afxsock.h>		// MFC socket extensions
+

ADDED   examples/vstudio/wforms/AssemblyInfo.cpp
Index: examples/vstudio/wforms/AssemblyInfo.cpp
==================================================================
--- /dev/null
+++ examples/vstudio/wforms/AssemblyInfo.cpp
@@ -0,0 +1,18 @@
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Runtime::CompilerServices;
+using namespace System::Runtime::InteropServices;
+using namespace System::Security::Permissions;
+
+[assembly:AssemblyTitleAttribute("wforms")];
+[assembly:AssemblyDescriptionAttribute("")];
+[assembly:AssemblyConfigurationAttribute("")];
+[assembly:AssemblyCompanyAttribute("the MySQL++ project")];
+[assembly:AssemblyProductAttribute("MySQL++ Windows Forms Example")];
+[assembly:AssemblyCopyrightAttribute("Copyright © 2007 by ETR, Inc.")];
+[assembly:AssemblyTrademarkAttribute("")];
+[assembly:AssemblyCultureAttribute("")];
+[assembly:AssemblyVersionAttribute("1.0.*")];
+[assembly:ComVisible(false)];
+[assembly:CLSCompliantAttribute(true)];
+[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];

ADDED   examples/vstudio/wforms/MainForm.h
Index: examples/vstudio/wforms/MainForm.h
==================================================================
--- /dev/null
+++ examples/vstudio/wforms/MainForm.h
@@ -0,0 +1,346 @@
+/***********************************************************************
+ MainForm.cpp - Defines the dialog box behavior for the MySQL++ C++/CLI
+	Windows Forms example.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others 
+ may also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#pragma once
+
+#include <mysql++.h>
+
+namespace wforms {
+
+	using namespace Microsoft::Win32;
+	using namespace System;
+	using namespace System::ComponentModel;
+	using namespace System::Collections;
+	using namespace System::Windows::Forms;
+	using namespace System::Data;
+	using namespace System::Drawing;
+
+	public ref class MainForm : public System::Windows::Forms::Form
+	{
+	public:
+		MainForm()
+		{
+			InitializeComponent();
+			LoadDefaults();
+		}
+
+	protected:
+		~MainForm()
+		{
+			if (components) {
+				delete components;
+			}
+		}
+
+	private:
+		// Insert a text string into the output list control
+		Void AddMessage(String^ msg)
+		{
+			resultsList_->Items->Add(msg);
+		}
+
+		// Handle Close button click by shutting down application
+		Void CloseButton_Click(Object^ sender, EventArgs^ e)
+		{
+			Application::Exit();
+		}
+		
+		// Handle Connect button click.  The body of this function is
+		// essentially the same as the simple2 command line example, with
+		// some GUI overhead.
+		Void ConnectButton_Click(Object^ sender, EventArgs^ e)
+		{
+			// Clear out the results list, in case this isn't the first time
+			// we've come in here.
+			resultsList_->Items->Clear();
+
+			// Translate the Unicode text we get from the UI into the UTF-8
+			// form that MySQL wants.
+			const int kInputBufSize = 100;
+			char acServerAddress[kInputBufSize];
+			char acUserName[kInputBufSize];
+			char acPassword[kInputBufSize];
+			ToUTF8(acServerAddress, kInputBufSize, serverAddress_->Text);
+			ToUTF8(acUserName, kInputBufSize, userName_->Text);
+			ToUTF8(acPassword, kInputBufSize, password_->Text);
+
+			// Connect to the sample database.
+			mysqlpp::Connection con(false);
+			if (!con.connect("mysql_cpp_data", acServerAddress, acUserName,
+					acPassword)) {
+				AddMessage("Failed to connect to server:");
+				AddMessage(gcnew String(con.error()));
+				return;
+			}
+
+			// Retrieve a subset of the sample stock table set up by resetdb
+			mysqlpp::Query query = con.query();
+			query << "select item from stock";
+			mysqlpp::StoreQueryResult res = query.store();
+
+			if (res) {
+				// Display the result set
+				mysqlpp::Row row;
+				for (mysqlpp::Row::size_type i = 0; row = res.at(i); ++i) {
+					AddMessage(ToUCS2(row.at(0)));
+				}
+
+				// Retreive was successful, so save user inputs now
+				SaveInputs();
+			}
+			else {
+				// Retreive failed
+				AddMessage("Failed to get item list:");
+				AddMessage(ToUCS2(query.error()));
+			}
+		}
+
+		// Load the default input field values, if there are any
+		Void LoadDefaults()
+		{
+			RegistryKey^ settings = OpenSettingsRegistryKey();
+			if (settings) {
+				userName_->Text = LoadSetting(settings, L"user");
+				serverAddress_->Text = LoadSetting(settings, L"server");
+			}
+			
+			if (String::IsNullOrEmpty(userName_->Text)) {
+				userName_->Text = Environment::UserName;
+			}
+			if (String::IsNullOrEmpty(serverAddress_->Text)) {
+				serverAddress_->Text = L"localhost";
+			}
+		}
+
+		// Returns a setting from underneath the given registry key.
+		// Assumes that it's a string value under the MySQL++ examples' 
+		// settings area.
+		String^ LoadSetting(RegistryKey^ key, String^ name)
+		{
+			return (String^)key->GetValue(name);
+		}
+
+		// Returns a reference to the MySQL++ examples' settings area in the
+		// registry.
+		RegistryKey^ OpenSettingsRegistryKey()
+		{
+			RegistryKey^ key = Registry::CurrentUser->OpenSubKey(L"Software",
+					true);
+			return key ? key->CreateSubKey(L"MySQL++ Examples") : nullptr;
+		}
+
+		// Saves the input fields' values to the registry, except for the
+		// password field.
+		Void SaveInputs()
+		{
+			RegistryKey^ settings = OpenSettingsRegistryKey();
+			if (settings) {
+				SaveSetting(settings, "user", userName_->Text);
+				SaveSetting(settings, "server", serverAddress_->Text);
+			}			
+		}
+
+		// Saves the given value as a named entry under the given registry
+		// key.
+		Void SaveSetting(RegistryKey^ key, String^ name, String^ value)
+		{
+			key->SetValue(name, value);
+		}
+
+		// Takes a string in the .NET platform's native Unicode format and
+		// copies it to the given C string buffer in UTF-8 encoding.
+		Void ToUTF8(char* pcOut, int nOutLen, String^ sIn)
+		{
+			array<Byte>^ bytes = System::Text::Encoding::UTF8->GetBytes(sIn);
+			nOutLen = Math::Min(nOutLen - 1, bytes->Length);
+			System::Runtime::InteropServices::Marshal::Copy(bytes, 0, 
+				IntPtr(pcOut), nOutLen);
+			pcOut[nOutLen] = '\0';
+		}
+
+		// Takes the given C string encoded in UTF-8 and converts it to a
+		// Unicode string in the .NET platform's native Unicode encoding.
+		String^ ToUCS2(const char* utf8)
+		{
+			return gcnew String(utf8, 0, strlen(utf8), 
+					System::Text::Encoding::UTF8);
+		}
+
+	private: System::Windows::Forms::TextBox^ serverAddress_;
+	private: System::Windows::Forms::TextBox^ password_;
+	private: System::Windows::Forms::TextBox^ userName_;
+	private: System::Windows::Forms::ListBox^ resultsList_;
+	private: System::Windows::Forms::Button^ connectButton_;
+	private: System::Windows::Forms::Button^ closeButton_;
+	private: System::ComponentModel::Container^ components;
+
+#pragma region Windows Form Designer generated code
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		void InitializeComponent(void)
+		{
+			System::Windows::Forms::Label^  label1;
+			System::Windows::Forms::Label^  label2;
+			System::Windows::Forms::Label^  label3;
+			System::Windows::Forms::Label^  label4;
+			this->serverAddress_ = (gcnew System::Windows::Forms::TextBox());
+			this->password_ = (gcnew System::Windows::Forms::TextBox());
+			this->userName_ = (gcnew System::Windows::Forms::TextBox());
+			this->resultsList_ = (gcnew System::Windows::Forms::ListBox());
+			this->connectButton_ = (gcnew System::Windows::Forms::Button());
+			this->closeButton_ = (gcnew System::Windows::Forms::Button());
+			label1 = (gcnew System::Windows::Forms::Label());
+			label2 = (gcnew System::Windows::Forms::Label());
+			label3 = (gcnew System::Windows::Forms::Label());
+			label4 = (gcnew System::Windows::Forms::Label());
+			this->SuspendLayout();
+			// 
+			// label1
+			// 
+			label1->AutoSize = true;
+			label1->Location = System::Drawing::Point(29, 13);
+			label1->Name = L"label1";
+			label1->Size = System::Drawing::Size(41, 13);
+			label1->TabIndex = 6;
+			label1->Text = L"Server:";
+			label1->TextAlign = System::Drawing::ContentAlignment::TopRight;
+			// 
+			// label2
+			// 
+			label2->AutoSize = true;
+			label2->Location = System::Drawing::Point(9, 39);
+			label2->Name = L"label2";
+			label2->Size = System::Drawing::Size(61, 13);
+			label2->TabIndex = 7;
+			label2->Text = L"User name:";
+			label2->TextAlign = System::Drawing::ContentAlignment::TopRight;
+			// 
+			// label3
+			// 
+			label3->AutoSize = true;
+			label3->Location = System::Drawing::Point(14, 65);
+			label3->Name = L"label3";
+			label3->Size = System::Drawing::Size(56, 13);
+			label3->TabIndex = 8;
+			label3->Text = L"Password:";
+			label3->TextAlign = System::Drawing::ContentAlignment::TopRight;
+			// 
+			// label4
+			// 
+			label4->AutoSize = true;
+			label4->Location = System::Drawing::Point(25, 92);
+			label4->Name = L"label4";
+			label4->Size = System::Drawing::Size(45, 13);
+			label4->TabIndex = 9;
+			label4->Text = L"Results:";
+			label4->TextAlign = System::Drawing::ContentAlignment::TopRight;
+			// 
+			// serverAddress_
+			// 
+			this->serverAddress_->Location = System::Drawing::Point(70, 9);
+			this->serverAddress_->Name = L"serverAddress_";
+			this->serverAddress_->Size = System::Drawing::Size(139, 20);
+			this->serverAddress_->TabIndex = 0;
+			// 
+			// password_
+			// 
+			this->password_->Location = System::Drawing::Point(70, 61);
+			this->password_->Name = L"password_";
+			this->password_->Size = System::Drawing::Size(139, 20);
+			this->password_->TabIndex = 2;
+			this->password_->UseSystemPasswordChar = true;
+			// 
+			// userName_
+			// 
+			this->userName_->Location = System::Drawing::Point(70, 35);
+			this->userName_->Name = L"userName_";
+			this->userName_->Size = System::Drawing::Size(139, 20);
+			this->userName_->TabIndex = 1;
+			// 
+			// resultsList_
+			// 
+			this->resultsList_->Enabled = false;
+			this->resultsList_->FormattingEnabled = true;
+			this->resultsList_->Location = System::Drawing::Point(70, 88);
+			this->resultsList_->Name = L"resultsList_";
+			this->resultsList_->Size = System::Drawing::Size(228, 95);
+			this->resultsList_->TabIndex = 3;
+			this->resultsList_->TabStop = false;
+			// 
+			// connectButton_
+			// 
+			this->connectButton_->Location = System::Drawing::Point(224, 9);
+			this->connectButton_->Name = L"connectButton_";
+			this->connectButton_->Size = System::Drawing::Size(75, 23);
+			this->connectButton_->TabIndex = 3;
+			this->connectButton_->Text = L"Connect!";
+			this->connectButton_->UseVisualStyleBackColor = true;
+			this->connectButton_->Click += gcnew System::EventHandler(this, &MainForm::ConnectButton_Click);
+			// 
+			// closeButton_
+			// 
+			this->closeButton_->DialogResult = System::Windows::Forms::DialogResult::Cancel;
+			this->closeButton_->Location = System::Drawing::Point(224, 38);
+			this->closeButton_->Name = L"closeButton_";
+			this->closeButton_->Size = System::Drawing::Size(75, 23);
+			this->closeButton_->TabIndex = 4;
+			this->closeButton_->Text = L"Close";
+			this->closeButton_->UseVisualStyleBackColor = true;
+			this->closeButton_->Click += gcnew System::EventHandler(this, &MainForm::CloseButton_Click);
+			// 
+			// MainForm
+			// 
+			this->AcceptButton = this->connectButton_;
+			this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
+			this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
+			this->CancelButton = this->closeButton_;
+			this->ClientSize = System::Drawing::Size(310, 192);
+			this->ControlBox = false;
+			this->Controls->Add(label4);
+			this->Controls->Add(label3);
+			this->Controls->Add(label2);
+			this->Controls->Add(label1);
+			this->Controls->Add(this->closeButton_);
+			this->Controls->Add(this->connectButton_);
+			this->Controls->Add(this->resultsList_);
+			this->Controls->Add(this->userName_);
+			this->Controls->Add(this->password_);
+			this->Controls->Add(this->serverAddress_);
+			this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog;
+			this->MaximizeBox = false;
+			this->MinimizeBox = false;
+			this->Name = L"MainForm";
+			this->ShowIcon = false;
+			this->Text = L"MySQL++ Windows Forms Examples";
+			this->ResumeLayout(false);
+			this->PerformLayout();
+
+		}
+#pragma endregion
+};
+}

ADDED   examples/vstudio/wforms/MainForm.resX
Index: examples/vstudio/wforms/MainForm.resX
==================================================================
--- /dev/null
+++ examples/vstudio/wforms/MainForm.resX
@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <metadata name="label1.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+    <value>False</value>
+  </metadata>
+  <metadata name="label2.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+    <value>False</value>
+  </metadata>
+  <metadata name="label3.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+    <value>False</value>
+  </metadata>
+  <metadata name="label4.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+    <value>False</value>
+  </metadata>
+</root>

ADDED   examples/vstudio/wforms/resource.h
Index: examples/vstudio/wforms/resource.h
==================================================================
--- /dev/null
+++ examples/vstudio/wforms/resource.h
@@ -0,0 +1,3 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by app.rc

ADDED   examples/vstudio/wforms/wforms.cpp
Index: examples/vstudio/wforms/wforms.cpp
==================================================================
--- /dev/null
+++ examples/vstudio/wforms/wforms.cpp
@@ -0,0 +1,17 @@
+// wforms.cpp : main project file.
+
+#include "MainForm.h"
+
+using namespace wforms;
+
+[STAThreadAttribute]
+int main(array<System::String ^> ^args)
+{
+	// Enabling Windows XP visual effects before any controls are created
+	Application::EnableVisualStyles();
+	Application::SetCompatibleTextRenderingDefault(false); 
+
+	// Create the main window and run it
+	Application::Run(gcnew MainForm());
+	return 0;
+}

ADDED   exrun
Index: exrun
==================================================================
--- /dev/null
+++ exrun
@@ -0,0 +1,61 @@
+#!/bin/sh
+if [ -z "$1" ]
+then
+	echo "usage: $0 [TOOL] <example> [args...]"
+	echo
+	echo "   Runs the given example, using the library in the current directory"
+	echo "   instead of using the system library search mechanism.  Accepts an "
+	echo "   arbitrary number of arguments."
+	echo
+	echo "   TOOL can be 'valgrind', 'gdb', or 'ldd', which causes exrun to"
+	echo "   run the example program under the given tool."
+	echo
+	exit 1
+fi
+
+TOOL=
+PROG=$1
+if [ "$PROG" = 'valgrind' ]
+then
+	TOOL='valgrind'
+	shift
+	PROG=$1
+elif [ "$PROG" = 'gdb' ]
+then
+	TOOL='gdb --args'
+	shift
+	PROG=$1
+elif [ "$PROG" = 'ldd' ]
+then
+	TOOL='ldd'
+	shift
+	PROG=$1
+fi
+
+shift
+if [ -e "$PROG" ]
+then
+	if [ `uname -s` = 'Darwin' ]
+	then
+		DYLD_LIBRARY_PATH=. $TOOL ./$PROG $*
+	elif [ `uname -o` = 'Cygwin' ]
+	then
+		# Cygwin build case; see below for bash-as-DOS-shell case
+		PATH=. $TOOL ./$PROG $*
+	elif [ -e /usr/bin/ldd ]
+	then
+		LD_LIBRARY_PATH=. $TOOL ./$PROG $*
+	else
+		echo "ERROR: I don't grok this system's dynamic linkage system."
+	fi
+elif [ `uname -o` = 'Cygwin' ]
+then
+	# VC++ build, but using Cygwin's bash as shell to run programs
+	cmd.exe /c exrun.bat $PROG $*
+else
+	echo "usage: $0 [TOOL] <example> [args...]"
+	echo
+	echo "   Run $0 without arguments for more detailed usage info."
+	echo
+	exit 1
+fi

ADDED   exrun.bat
Index: exrun.bat
==================================================================
--- /dev/null
+++ exrun.bat
@@ -0,0 +1,9 @@
+@echo off
+set PROG=%1
+if not exist %PROG% set PROG=%1.exe
+if not exist %PROG% set PROG=Debug\%1
+if not exist %PROG% set PROG=Debug\%1.exe
+shift
+
+set PATH=Debug;%PATH%
+%PROG% %1 %2 %3 %4 %5 %6 %7 %8 %9

ADDED   install.bat
Index: install.bat
==================================================================
--- /dev/null
+++ install.bat
@@ -0,0 +1,38 @@
+@echo off
+if "%1" == "" goto error
+
+set BASE_DIR=c:\mysql++
+set INST_INC_DIR=%BASE_DIR%\include
+set INST_LIB_DIR=%BASE_DIR%\%1
+
+if not exist %BASE_DIR% mkdir %BASE_DIR%
+if not exist %INST_INC_DIR% mkdir %INST_INC_DIR%
+if not exist %INST_LIB_DIR% mkdir %INST_LIB_DIR%
+if not exist %INST_LIB_DIR%\debug mkdir %INST_LIB_DIR%\debug
+if not exist %INST_LIB_DIR%\release mkdir %INST_LIB_DIR%\release
+
+copy lib\*.h "%INST_INC_DIR%" > NUL
+
+if exist *.a goto install_mingw
+copy debug\*.dll "%INST_LIB_DIR%\debug" > NUL
+copy debug\*.lib "%INST_LIB_DIR%\debug" > NUL
+copy release\*.dll "%INST_LIB_DIR%\release" > NUL
+copy release\*.lib "%INST_LIB_DIR%\release" > NUL
+goto install_done
+:install_mingw
+copy *.a "%INST_LIB_DIR%\debug" > NUL
+echo WARNING: I assume you built a debug version of the library, as that
+echo is what you get with MinGW unless you make a special effort.  You
+echo must do a manual install if you make a release version.
+
+:install_done
+echo MySQL++ (%1 version) installed successfully!
+goto end
+
+:error
+echo usage: install [subdir]
+echo.
+echo 	Installs MySQL++ into the given subdirectory of %BASE_DIR%
+
+:end
+

ADDED   lib/Doxyfile.in
Index: lib/Doxyfile.in
==================================================================
--- /dev/null
+++ lib/Doxyfile.in
@@ -0,0 +1,1055 @@
+# Doxyfile 1.5.2-1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = MySQL++
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = @PACKAGE_VERSION@
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = ../doc
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, 
+# Croatian, Czech, Danish, Dutch, Finnish, French, German, Greek, Hungarian, 
+# Italian, Japanese, Japanese-en (Japanese with English messages), Korean, 
+# Korean-en, Lithuanian, Norwegian, Polish, Portuguese, Romanian, Russian, 
+# Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all 
+# inherited members of a class in the documentation of that class as if those 
+# members were ordinary class members. Constructors, destructors and assignment 
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful is your file systems 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like the Qt-style comments (thus requiring an 
+# explicit @brief command for a brief description.
+
+JAVADOC_AUTOBRIEF      = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the DETAILS_AT_TOP tag is set to YES then Doxygen 
+# will output the detailed description near the top, like JavaDoc.
+# If set to NO, the detailed description appears after the member 
+# documentation.
+
+DETAILS_AT_TOP         = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 8
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C 
+# sources only. Doxygen will then generate output that is more tailored for C. 
+# For instance, some of the names that are used will be different. The list 
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java 
+# sources only. Doxygen will then generate output that is more tailored for Java. 
+# For instance, namespaces will be presented as packages, qualified scopes 
+# will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or define consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and defines in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. Optionally the format may contain 
+# $version, which will be replaced by the version of the file (if it could 
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces.
+
+INPUT                  = 
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank the following patterns are tested: 
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
+
+FILE_PATTERNS          = 
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = querydef.h ssqls.h
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
+# directories that are symbolic links (a Unix filesystem feature) are excluded 
+# from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. Note that the wildcards are matched 
+# against the file with absolute path, so to exclude all test directories 
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = 
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES (the default) 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES (the default) 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = YES
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = html/refman
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = ../doc/html/refman/_header.html
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = 
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [1..20]) 
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
+# generated containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, 
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are 
+# probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = YES
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = letter
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader.  This is useful 
+# if you want to understand what is going on.  On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. To prevent a macro definition from being 
+# undefined via #undef or recursively expanded use the := operator 
+# instead of the = operator.
+
+PREDEFINED             = DOXYGEN_IGNORE
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED      = 
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
+# doxygen's preprocessor will remove all function-like macros that are alone 
+# on a line, have an all uppercase name, and do not end with a semicolon. Such 
+# function macros are typically used for boiler-plate code, and will confuse 
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#   TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#   TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
+# or super classes. Setting the tag to NO turns the diagrams off. Note that 
+# this option is superseded by the HAVE_DOT option below. This is only a 
+# fallback. It is recommended to install and use dot, since it yields more 
+# powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = YES
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will 
+# generate a call dependency graph for every global function or class method. 
+# Note that enabling this option will significantly increase the time of a run. 
+# So in most cases it will be better to enable call graphs for selected 
+# functions only using the \callgraph command.
+
+CALL_GRAPH             = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, jpg, or gif
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               = 
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be 
+# used. If set to NO the values of all tags below this one will be ignored.
+
+SEARCHENGINE           = NO

ADDED   lib/autoflag.h
Index: lib/autoflag.h
==================================================================
--- /dev/null
+++ lib/autoflag.h
@@ -0,0 +1,57 @@
+/// \file autoflag.h
+/// \brief Defines a template for setting a flag within a given variable
+/// scope, and resetting it when exiting that scope.
+
+/***********************************************************************
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others
+ may also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_AUTOFLAG_H)
+#define MYSQLPP_AUTOFLAG_H
+
+/// \brief A template for setting a flag on a variable as long as the
+/// object that set it is in scope.  Flag resets when object goes
+/// out of scope.  Works on anything that looks like bool.
+
+template <class T = bool>
+class AutoFlag
+{
+public:
+	/// \brief Constructor: sets ref to true.
+	AutoFlag(T& ref) :
+	referent_(ref)
+	{
+		referent_ = true;
+	}
+
+	/// \brief Destructor: sets referent passed to ctor to false.
+	~AutoFlag()
+	{
+		referent_ = false;
+	}
+
+private:
+	T& referent_;
+};
+
+#endif // !defined(MYSQLPP_AUTOFLAG_H)
+

ADDED   lib/beemutex.cpp
Index: lib/beemutex.cpp
==================================================================
--- /dev/null
+++ lib/beemutex.cpp
@@ -0,0 +1,182 @@
+/***********************************************************************
+ beemutex.cpp - Implements the BeecryptMutex class.  The name comes
+ 	from the fact that we lifted this essentially intact from the
+	Beecrypt library, which is also LGPL.  See beecrypt.h for the list
+	of changes we made on integrating it into MySQL++.
+
+ Copyright (c) 2004 Beeyond Software Holding BV and (c) 2007 by
+ Educational Technology Resources, Inc.  Others may also hold
+ copyrights on code in this file.  See the CREDITS file in the top
+ directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "beemutex.h"
+
+#include "common.h"
+
+#include <errno.h>
+#include <string.h>
+
+
+namespace mysqlpp {
+
+#define ACTUALLY_DOES_SOMETHING
+#if defined(HAVE_SYNCH_H)
+    typedef mutex_t bc_mutex_t;
+#elif defined(HAVE_PTHREAD)
+    typedef pthread_mutex_t bc_mutex_t;
+#elif defined(MYSQLPP_PLATFORM_WINDOWS)
+    typedef HANDLE bc_mutex_t;
+#else
+// No supported mutex type found, so class becomes a no-op.
+#	undef ACTUALLY_DOES_SOMETHING
+#endif
+
+#if defined(ACTUALLY_DOES_SOMETHING)
+	static bc_mutex_t* impl_ptr(void* p)
+			{ return static_cast<bc_mutex_t*>(p); }
+#	if defined(MYSQLPP_PLATFORM_WINDOWS)
+		static bc_mutex_t impl_val(void* p)
+				{ return *static_cast<bc_mutex_t*>(p); }
+#	endif
+#endif
+
+
+BeecryptMutex::BeecryptMutex() throw (MutexFailed)
+#if defined(ACTUALLY_DOES_SOMETHING)
+	: pmutex_(new bc_mutex_t)
+#endif
+{
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+	*impl_ptr(pmutex_) = CreateMutex((LPSECURITY_ATTRIBUTES) 0, FALSE,
+			(LPCTSTR) 0);
+	if (!impl_val(pmutex_))
+		throw MutexFailed("CreateMutex failed");
+#else
+#	if HAVE_SYNCH_H || HAVE_PTHREAD
+	register int rc;
+#	endif
+#	if HAVE_SYNCH_H
+		if ((rc = mutex_init(impl_ptr(pmutex_), USYNC_THREAD, 0)))
+			throw MutexFailed(strerror(rc));
+#	elif HAVE_PTHREAD
+		if ((rc = pthread_mutex_init(impl_ptr(pmutex_), 0)))
+			throw MutexFailed(strerror(rc));
+#	endif
+#endif
+}
+
+
+BeecryptMutex::~BeecryptMutex()
+{
+#if defined(ACTUALLY_DOES_SOMETHING)
+#	if defined(MYSQLPP_PLATFORM_WINDOWS)
+		CloseHandle(impl_val(pmutex_));
+#	elif HAVE_SYNCH_H
+		mutex_destroy(impl_ptr(pmutex_));
+#	elif HAVE_PTHREAD
+		pthread_mutex_destroy(impl_ptr(pmutex_));
+#	endif
+
+	delete impl_ptr(pmutex_);
+#endif
+}
+
+
+void
+BeecryptMutex::lock() throw (MutexFailed)
+{
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+	if (WaitForSingleObject(impl_val(pmutex_), INFINITE) == WAIT_OBJECT_0)
+		return;
+	throw MutexFailed("WaitForSingleObject failed");
+#else
+#	if HAVE_SYNCH_H || HAVE_PTHREAD
+	register int rc;
+#	endif
+#	if HAVE_SYNCH_H
+		if ((rc = mutex_lock(impl_ptr(pmutex_))))
+			throw MutexFailed(strerror(rc));
+#	elif HAVE_PTHREAD
+		if ((rc = pthread_mutex_lock(impl_ptr(pmutex_))))
+			throw MutexFailed(strerror(rc));
+#	endif
+#endif
+}
+
+
+bool
+BeecryptMutex::trylock() throw (MutexFailed)
+{
+#if defined(ACTUALLY_DOES_SOMETHING)
+#	if defined(MYSQLPP_PLATFORM_WINDOWS)
+		switch (WaitForSingleObject(impl_val(pmutex_), 0)) {
+			case WAIT_TIMEOUT:
+				return false;
+			case WAIT_OBJECT_0:
+				return true;
+			default:
+				throw MutexFailed("WaitForSingleObbject failed");
+		}
+#	else
+		register int rc;
+#		if HAVE_SYNCH_H
+			if ((rc = mutex_trylock(impl_ptr(pmutex_))) == 0)
+				return true;
+			if (rc == EBUSY)
+				return false;
+			throw MutexFailed(strerror(rc));
+#		elif HAVE_PTHREAD
+			if ((rc = pthread_mutex_trylock(impl_ptr(pmutex_))) == 0)
+				return true;
+			if (rc == EBUSY)
+				return false;
+			throw MutexFailed(strerror(rc));
+#		endif
+#	endif
+#else
+	return true;		// no-op build, so always succeed
+#endif
+}
+
+
+void
+BeecryptMutex::unlock() throw (MutexFailed)
+{
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+	if (!ReleaseMutex(impl_val(pmutex_)))
+		throw MutexFailed("ReleaseMutex failed");
+#else
+#	if HAVE_SYNCH_H || HAVE_PTHREAD
+		register int rc;
+#	endif
+#	if HAVE_SYNCH_H
+		if ((rc = mutex_unlock(impl_ptr(pmutex_))))
+			throw MutexFailed(strerror(rc));
+#	elif HAVE_PTHREAD
+		if ((rc = pthread_mutex_unlock(impl_ptr(pmutex_))))
+			throw MutexFailed(strerror(rc));
+#	endif
+#endif
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/beemutex.h
Index: lib/beemutex.h
==================================================================
--- /dev/null
+++ lib/beemutex.h
@@ -0,0 +1,118 @@
+/// \file beemutex.h
+/// \brief MUTually EXclusive lock class.
+/// \author Bob Deblier <bob.deblier@telenet.be>
+///
+/// Modified by Warren Young of Educational Technology Resources, Inc.
+/// from version in Beecrypt 4.1.2:
+///
+/// - minor style changes to make it fit within MySQL++
+/// - changed init() to a ctor and destroy() to a dtor
+/// - class just becomes a no-op if no supported mutex type is available
+/// - throwing MutexFailed instead of \c char*
+/// - moved all method implementations from inline in the .h file to
+///   a .cpp file so we don't have to make the header depend on config.h
+///   on autoconf-using systems
+/// - made private mutex member a void* so we don't have to define the
+///   full type in the .h file, due to previous item
+/// - added more Doxygen comments, and changed some existing comments
+
+/***********************************************************************
+ Copyright (c) 2004 Beeyond Software Holding BV and (c) 2007-2008
+ by Educational Technology Resources, Inc.  Others may also hold
+ copyrights on code in this file.  See the CREDITS file in the top
+ directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_BEEMUTEX_H)
+#define MYSQLPP_BEEMUTEX_H
+
+#include "exceptions.h"
+
+namespace mysqlpp {
+
+/// \brief Wrapper around platform-specific mutexes.
+///
+/// This class is only intended to be used within the library.  We don't
+/// really want to support this as a general purpose class.  If it works
+/// for you as-is, that's great, we won't try to stop you.  But if you
+/// run into a problem that doesn't affect MySQL++ itself, we're not
+/// likely to bother enhancing this class to fix the problem.
+class MYSQLPP_EXPORT BeecryptMutex
+{
+public:
+	/// \brief Create the mutex object
+	///
+	/// Throws a MutexFailed exception if we can't acquire the lock for
+	/// some reason.  The exception contains a message saying why.
+    BeecryptMutex() throw (MutexFailed);
+
+	/// \brief Destroy the mutex
+	///
+	/// Failures are quietly ignored.
+    ~BeecryptMutex();
+
+	/// \brief Acquire the mutex, blocking if it can't be acquired
+	/// immediately.
+    void lock() throw (MutexFailed);
+
+	/// \brief Acquire the mutex immediately and return true, or return
+	/// false if it would have to block to acquire the mutex.
+    bool trylock() throw (MutexFailed);
+
+	/// \brief Release the mutex
+    void unlock() throw (MutexFailed);
+
+private:
+    void* pmutex_;
+};
+
+
+/// \brief Wrapper around BeecryptMutex to add scope-bound locking
+/// and unlocking.
+///
+/// This allows code to lock a mutex and ensure it will unlock on exit
+/// from the enclosing scope even in the face of exceptions.  This is
+/// separate from BeecryptMutex because we don't want to make this
+/// behavior mandatory.
+
+class ScopedLock
+{
+public:
+	/// \brief Lock the mutex.
+	explicit ScopedLock(BeecryptMutex& mutex) :
+	mutex_(mutex)
+	{
+		mutex.lock();
+	}
+
+	/// \brief Unlock the mutex.
+    ~ScopedLock() { mutex_.unlock(); }
+
+private:
+    ScopedLock(const ScopedLock&);				// can't copy
+    ScopedLock& operator =(const ScopedLock&);	// can't assign
+
+    BeecryptMutex& mutex_;	///< the mutex object we manage
+};
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_BEEMUTEX_H)
+

ADDED   lib/common.h
Index: lib/common.h
==================================================================
--- /dev/null
+++ lib/common.h
@@ -0,0 +1,185 @@
+/// \file common.h
+/// \brief This file includes top-level definitions for use both
+/// internal to the library, and outside it.  Contrast mysql++.h
+///
+/// This file mostly takes care of platform differences.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_COMMON_H)
+#define MYSQLPP_COMMON_H
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for the following stuff.
+
+// Enable SSQLS by default.  Turned off below on platforms where we
+// know it doesn't work.
+#define MYSQLPP_SSQLS_COMPATIBLE
+
+// For all platforms but Visual C++ 2003, the following macro is just
+// an alias for "*this".  It needs a more complicated definition on
+// VC++ 2003 to work around an error in the overloaded operator lookup
+// logic.  For an explanation of the problem, see:
+// http://groups.google.com/group/microsoft.public.vc.stl/browse_thread/thread/9a68d84644e64f15
+#define MYSQLPP_QUERY_THISPTR *this
+
+// Work out major platform-specific stuff here.
+#if defined(__WIN32__) || defined(_WIN32)
+#	define MYSQLPP_PLATFORM_WINDOWS
+
+	// Windows compiler support.  Tested with Microsoft Visual C++,
+	// Borland C++ Builder, and MinGW GCC.
+#	include <winsock.h>
+
+	// Stuff for Visual C++ only
+#	if defined(_MSC_VER)
+#		define MYSQLPP_PLATFORM_VISUAL_CPP
+		// MS *still* doesn't ship stdint.h, through VC++ 2008 at least.
+		// This means we have to take a wild guess at appropriate
+		// integer types in lib/sql_types.h.  See test/inttypes.cpp for
+		// tests that check whether we've guessed well.
+#		define MYSQLPP_NO_STDINT_H
+#		if _MSC_VER < 1400
+			// Workarounds for limitations of VC++ 2003 that are fixed
+			// in 2005 and later.
+#			undef MYSQLPP_QUERY_THISPTR
+#			define MYSQLPP_QUERY_THISPTR dynamic_cast<std::ostream&>(*this)
+#			undef MYSQLPP_SSQLS_COMPATIBLE
+#		elif !defined(_STLP_VERSION) && !defined(_STLP_VERSION_STR)
+			// VC++ 2005 or newer and not using STLport, so #define
+			// portability flags indicating features we can use from
+			// the compiler's native RTL.
+#			define MYSQLPP_HAVE_LOCALTIME_S
+#			define MYSQLPP_HAVE_STD__NOINIT
+#		endif
+
+		// Disable complaints about STL data members: VC++ believes
+		// these need to be __declspec(dllexport) for some reason.
+#		pragma warning(disable: 4251)
+		// Disable complaint that VC++ doesn't grok throw specs
+#		pragma warning(disable: 4290)
+		// Disable whining about using 'this' as a member initializer on VC++.
+#		pragma warning(disable: 4355)
+		// Disable whining about implicit conversions to bool
+#		pragma warning(disable: 4800)
+		// Disable nagging about new "secure" functions like strncpy_s()
+#		pragma warning(disable: 4996)
+		// Call _snprintf() for VC++ version of snprintf() function
+#		define snprintf _snprintf
+#	endif
+
+	// Define DLL import/export tags for Windows compilers, where we build
+	// the library into a DLL, for LGPL license compatibility reasons.
+	// (This is based on a similar mechanism in wxWindows.)
+
+	#ifdef MYSQLPP_MAKING_DLL
+		// When making the DLL, export tagged symbols, so they appear
+		// in the import library.
+		#define MYSQLPP_EXPORT __declspec(dllexport)
+	#elif !defined(MYSQLPP_NO_DLL)
+		// We must be _using_ the DLL, so import symbols instead.
+		#define MYSQLPP_EXPORT __declspec(dllimport)
+	#else
+		// Not making a DLL at all, so no-op these declspecs
+		#define MYSQLPP_EXPORT
+	#endif
+#else
+	// If not Windows, we assume some sort of Unixy build environment,
+	// where autotools is used.  (This includes Cygwin!)  #include the
+	// config.h file only if this file was included from a non-header
+	// file, because headers must not be dependent on config.h.
+#	if defined(MYSQLPP_NOT_HEADER)
+#		include "config.h"
+#	endif
+
+	// Make DLL stuff a no-op on this platform.
+	#define MYSQLPP_EXPORT
+#endif
+
+#if defined(MYSQLPP_MYSQL_HEADERS_BURIED)
+#	include <mysql/mysql_version.h>
+#else
+#	include <mysql_version.h>
+#endif
+
+namespace mysqlpp {
+
+/// \brief Alias for 'true', to make code requesting exceptions more
+/// readable.
+const bool use_exceptions = true;
+
+/// \brief Used to disambiguate overloads of equal_list() in SSQLSes.
+enum sql_cmp_type { sql_use_compare };
+
+#if !defined(DOXYGEN_IGNORE)
+// Figure out how to get large integer support on this system.  Suppress
+// refman documentation for these typedefs, as they're system-dependent.
+#if defined(MYSQLPP_NO_LONG_LONGS)
+// Alias "longlong" and "ulonglong" to the regular "long" counterparts
+typedef unsigned long ulonglong;
+typedef long longlong;
+#elif defined(_MSC_VER)
+// It's VC++, so we'll use Microsoft's 64-bit integer types
+typedef unsigned __int64 ulonglong;
+typedef __int64 longlong;
+#else
+// No better idea, so assume the C99 convention.  If your compiler
+// doesn't support this, please provide a patch to extend this ifdef, or
+// define MYSQLPP_NO_LONG_LONGS.
+typedef unsigned long long ulonglong;
+typedef long long longlong;
+#endif
+#endif // !defined(DOXYGEN_IGNORE)
+
+#if !defined(MYSQLPP_NO_UNSIGNED_INT_TYPES)
+/// \brief Contraction for 'unsigned long'
+///
+/// This is not to be used within the library or directly by end-user
+/// code.  It exists to make the MySQL C API headers happy: my_global.h
+/// defines it, but we can't use it in MySQL++, so we do it ourselves.
+typedef unsigned long ulong;
+#endif
+
+} // end namespace mysqlpp
+
+// The MySQL headers define these macros, which is completely wrong in a
+// C++ project.  Undo the damage.
+#undef min
+#undef max
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+// Now that we've defined all the stuff above, we can pull in the full
+// MySQL header.  Basically, the above largely replaces MySQL's my_global.h
+// while actually working with C++.  This is why we disobey the MySQL
+// developer docs, which recommend including my_global.h before mysql.h.
+#if defined(MYSQLPP_MYSQL_HEADERS_BURIED)
+#	include <mysql/mysql.h>
+#else
+#	include <mysql.h>
+#endif
+
+#endif // !defined(MYSQLPP_COMMON_H)

ADDED   lib/comparable.h
Index: lib/comparable.h
==================================================================
--- /dev/null
+++ lib/comparable.h
@@ -0,0 +1,94 @@
+/// \file comparable.h
+/// \brief Declares the Comparable<T> mixin
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_COMPARABLE_H)
+#define MYSQLPP_COMPARABLE_H
+
+/// \brief Mix-in that gives its subclass a full set of comparison
+/// operators.
+///
+/// Simply by inheriting publically from this and implementing
+/// compare(), the subclass gains a full set of comparison operators,
+/// because all of the operators are implemented in terms of compare().
+template <class T>
+class Comparable
+{
+public:
+	/// \brief Returns true if "other" is equal to this object
+	bool operator ==(const T& other) const
+	{
+		return !compare(other);
+	}
+
+	/// \brief Returns true if "other" is not equal to this object
+	bool operator !=(const T& other) const
+	{
+		return compare(other);
+	}
+
+	/// \brief Returns true if "other" is less than this object
+	bool operator <(const T& other) const
+	{
+		return compare(other) < 0;
+	}
+
+	/// \brief Returns true if "other" is less than or equal to this object
+	bool operator <=(const T& other) const
+	{
+		return compare(other) <= 0;
+	}
+
+	/// \brief Returns true if "other" is greater than this object
+	bool operator >(const T& other) const
+	{
+		return compare(other) > 0;
+	}
+
+	/// \brief Returns true if "other" is greater than or equal to this object
+	bool operator >=(const T& other) const
+	{
+		return compare(other) >= 0;
+	}
+
+protected:
+	/// \brief Destroy object
+	///
+	/// This class has nothing to destroy, but declaring the dtor
+	/// virtual placates some compilers set to high warning levels.
+	/// Protecting it ensures you can't delete subclasses through base
+	/// class pointers, which makes no sense because this class isn't
+	/// made for polymorphism.  It's just a mixin.
+	virtual ~Comparable() { }
+
+	/// \brief Compare this object to another of the same type
+	///
+	/// Returns < 0 if this object is "before" the other, 0 of they are
+	/// equal, and > 0 if this object is "after" the other.
+	virtual int compare(const T& other) const = 0;
+};
+
+#endif // !defined(MYSQLPP_COMPARABLE_H)

ADDED   lib/connection.cpp
Index: lib/connection.cpp
==================================================================
--- /dev/null
+++ lib/connection.cpp
@@ -0,0 +1,383 @@
+/***********************************************************************
+ connection.cpp - Implements the Connection class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "connection.h"
+
+#include "dbdriver.h"
+#include "query.h"
+#include "result.h"
+
+using namespace std;
+
+namespace mysqlpp {
+
+Connection::Connection(bool te) :
+OptionalExceptions(te),
+driver_(new DBDriver()),
+copacetic_(true)
+{
+}
+
+
+Connection::Connection(const char* db, const char* server,
+		const char* user, const char* password, unsigned int port) :
+OptionalExceptions(),
+driver_(new DBDriver()),
+copacetic_(true)
+{
+	connect(db, server, user, password, port);
+}
+
+
+Connection::Connection(const Connection& other) :
+OptionalExceptions(),
+driver_(new DBDriver(*other.driver_))
+{
+	copy(other);
+}
+
+
+Connection::~Connection()
+{
+	disconnect();
+	delete driver_;
+}
+
+
+void
+Connection::build_error_message(const char* core)
+{
+	error_message_ = "Can't ";
+	error_message_ += core;
+	error_message_ += " while disconnected";
+}
+
+
+std::string
+Connection::client_version() const
+{
+	return driver_->client_version();
+}
+
+
+bool
+Connection::connect(const char* db, const char* server,
+		const char* user, const char* password, unsigned int port)
+{
+	// Figure out what the server parameter means, then try to establish
+	// the connection.
+	error_message_.clear();
+	string host, socket_name;
+	copacetic_ = parse_ipc_method(server, host, port, socket_name) &&
+			driver_->connect(host.c_str(),
+			(socket_name.empty() ? 0 : socket_name.c_str()), port, db,
+			user, password);
+
+	// If it failed, decide how to tell the user
+	if (!copacetic_ && throw_exceptions()) {
+		throw ConnectionFailed(error(), errnum());
+	}
+	else {
+		return copacetic_;
+	}
+}
+
+
+bool
+Connection::connected() const
+{
+	return driver_->connected();
+}
+
+
+void
+Connection::copy(const Connection& other)
+{
+	error_message_.clear();
+	set_exceptions(other.throw_exceptions());
+	driver_->copy(*other.driver_);
+}
+
+
+ulonglong
+Connection::count_rows(const std::string& table)
+{
+	error_message_.clear();
+	Query q(this, throw_exceptions());
+	q << "SELECT COUNT(*) FROM " << table;
+	if (StoreQueryResult res = q.store()) {
+		return res[0][0];
+	}
+	else {
+		return 0;
+	}
+}
+
+
+bool
+Connection::create_db(const std::string& db)
+{
+	error_message_.clear();
+	Query q(this, throw_exceptions());
+	q << "CREATE DATABASE " << db;
+	return q.exec();
+}
+
+
+void
+Connection::disconnect()
+{
+	error_message_.clear();
+	driver_->disconnect();
+}
+
+
+bool
+Connection::drop_db(const std::string& db)
+{
+	error_message_.clear();
+	Query q(this, throw_exceptions());
+	q << "DROP DATABASE " << db;
+	return q.exec();
+}
+
+
+int
+Connection::errnum()
+{
+	return driver_->errnum();
+}
+
+
+const char*
+Connection::error() const
+{
+	return error_message_.size() ? error_message_.c_str() : driver_->error();
+}
+
+
+std::string
+Connection::ipc_info() const
+{
+	return driver_->ipc_info();
+}
+
+
+bool
+Connection::kill(unsigned long tid) const
+{
+	error_message_.clear();
+	return driver_->kill(tid);
+}
+
+
+Connection&
+Connection::operator=(const Connection& rhs)
+{
+	copy(rhs);
+	return *this;
+}
+
+
+bool
+Connection::parse_ipc_method(const char* server, std::string& host,
+		unsigned int& port, std::string& socket_name)
+{
+	// NOTE: This routine has no connection type knowledge.  It can only
+	// recognize a 0 value for the server parameter.  All substantial
+	// tests are delegated to our specialized subclasses, which figure
+	// out what kind of connection the server address denotes.  We do
+	// the platform-specific tests first as they're the most reliable.
+	
+	if (server == 0) {
+		// Just take all the defaults
+		return true;
+	}
+	else if (WindowsNamedPipeConnection::is_wnp(server)) {
+		// Use Windows named pipes
+		host = server;
+		return true;
+	}
+	else if (UnixDomainSocketConnection::is_socket(server)) {
+		// Use Unix domain sockets
+		socket_name = server;
+		return true;
+	}
+	else {
+		// Failing above, it can only be some kind of TCP/IP address.
+		host = server;
+		return TCPConnection::parse_address(host, port, error_message_);
+	}
+}
+
+
+bool
+Connection::ping()
+{
+	if (connected()) {
+		error_message_.clear();
+		return driver_->ping();
+	}
+	else {
+		// Not connected, and we've forgotten everything we need in
+		// order to re-connect, if we once were connected.
+		build_error_message("ping database server");
+		return false;
+	}
+}
+
+
+int
+Connection::protocol_version() const
+{
+	return driver_->protocol_version();
+}
+
+
+Query
+Connection::query(const char* qstr)
+{
+	return Query(this, throw_exceptions(), qstr);
+}
+
+
+Query
+Connection::query(const std::string& qstr)
+{
+	return query(qstr.c_str());
+}
+
+
+bool
+Connection::select_db(const std::string& db)
+{
+	error_message_.clear();
+	if (connected()) {
+		if (driver_->select_db(db.c_str())) {
+			return true;
+		}
+		else {
+			if (throw_exceptions()) {
+				throw DBSelectionFailed(error(), errnum());
+			}
+			return false;
+		}
+	}
+	else {
+		build_error_message("select a database");
+		if (throw_exceptions()) {
+			throw DBSelectionFailed(error_message_.c_str());
+		}
+		return false;
+	}
+}
+
+
+std::string
+Connection::server_status() const
+{
+	return driver_->server_status();
+}
+
+
+std::string
+Connection::server_version() const
+{
+	return driver_->server_version();
+}
+
+
+bool
+Connection::set_option(Option* o)
+{
+	error_message_ = driver_->set_option(o);
+	if (error_message_.empty()) {
+		return true;
+	}
+	else {
+		if (throw_exceptions()) {
+			throw BadOption(error_message_, typeid(*o));
+		}
+		return false;
+	}
+}
+
+
+bool
+Connection::shutdown()
+{
+	error_message_.clear();
+	if (connected()) {
+		if (driver_->shutdown()) {
+			return true;
+		}
+		else {
+			if (throw_exceptions()) {
+				throw ConnectionFailed(error(), errnum());
+			}
+			return false;
+		}
+	}
+	else {
+		build_error_message("shutdown database server");
+		if (throw_exceptions()) {
+			throw ConnectionFailed(error_message_.c_str());
+		}
+		return false;
+	}
+}
+
+
+bool
+Connection::thread_aware()
+{
+	return DBDriver::thread_aware();
+}
+
+
+void
+Connection::thread_end()
+{
+	DBDriver::thread_end();
+}
+
+
+unsigned long 
+Connection::thread_id() 
+{
+	return driver_->thread_id();
+}
+
+
+bool
+Connection::thread_start()
+{
+	return DBDriver::thread_start();
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/connection.h
Index: lib/connection.h
==================================================================
--- /dev/null
+++ lib/connection.h
@@ -0,0 +1,368 @@
+/// \file connection.h
+/// \brief Declares the Connection class.
+///
+/// Every program using MySQL++ must create a Connection object, which
+/// manages information about the connection to the database server, and
+/// performs connection-related operations once the connection is up.
+/// Subordinate classes, such as Query and Row take their defaults as
+/// to whether exceptions are thrown when errors are encountered from
+/// the Connection object that created them, directly or indirectly.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_CONNECTION_H)
+#define MYSQLPP_CONNECTION_H
+
+#include "common.h"
+
+#include "noexceptions.h"
+#include "options.h"
+
+#include <string>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class MYSQLPP_EXPORT Query;
+class DBDriver;
+#endif
+
+/// \brief Manages the connection to the database server.
+///
+/// This class is a thick wrapper around DBDriver, adding high-level
+/// error handling, utility functions, and abstraction away from
+/// underlying C API details.
+
+class MYSQLPP_EXPORT Connection : public OptionalExceptions
+{
+private:
+	/// \brief Pointer to bool data member, for use by safe bool
+	/// conversion operator.
+	///
+	/// \see http://www.artima.com/cppsource/safebool.html
+    typedef bool Connection::*private_bool_type;
+
+public:
+	/// \brief Create object without connecting to the database server.
+	///
+	/// \param te if true, exceptions are thrown on errors
+	Connection(bool te = true);
+
+	/// \brief Create object and connect to database server in one step.
+	///
+	/// This constructor allows you to most fully specify the options
+	/// used when connecting to the database server.
+	///
+	/// \param db name of database to select upon connection
+	/// \param server specifies the IPC method and parameters for
+	///     contacting the server; see below for details
+	/// \param user user name to log in under, or 0 to use the user
+	///		name this program is running under
+	/// \param password password to use when logging in
+	/// \param port TCP port number database server is listening on, or
+	///		0 to use default value; note that you may also give this as
+	///     part of the \c server parameter
+	///
+	/// The server parameter can be any of several different forms:
+	///
+	/// - \b 0: Let the database driver decide how to connect; usually
+	///   some sort of localhost IPC method.
+	/// - \b ".": On Windows, this means named pipes, if the server
+	///   supports it
+	/// - \b "/some/domain/socket/path": If the passed string doesn't
+	///   match one of the previous alternatives and we're on a system
+	///   that supports Unix domain sockets, MySQL++ will test it to see
+	///   if it names one, and use it if we have permission.
+	/// - \b "host.name.or.ip:port": If the previous test fails, or if
+	///   the system doesn't support Unix domain sockets at all, it
+	///   assumes the string is some kind of network address, optionally
+	///   followed by a colon and port.  The name can be in dotted quad
+	///   form, a host name, or a domain name.  The port can either be a
+	///   TCP/IP port number or a symbolic service name.  If a port or
+	///   service name is given here and a nonzero value is passed for
+	///   the \c port parameter, the latter takes precedence.
+	Connection(const char* db, const char* server = 0, const char* user = 0,
+			const char* password = 0, unsigned int port = 0);
+
+	/// \brief Establish a new connection using the same parameters as
+	/// an existing connection.
+	///
+	/// \param other existing Connection object
+	Connection(const Connection& other);
+
+	/// \brief Destroy object
+	virtual ~Connection();
+
+	/// \brief Get version of library underpinning the current database
+	/// driver.
+	std::string client_version() const;
+
+	/// \brief Connect to database after object is created.
+	///
+	/// It's better to use the connect-on-create constructor if you can.
+	/// See its documentation for the meaning of these parameters.
+	///
+	/// If you call this method on an object that is already connected
+	/// to a database server, the previous connection is dropped and a
+	/// new connection is established.
+	virtual bool connect(const char* db = 0, const char* server = 0,
+			const char* user = 0, const char* password = 0,
+			unsigned int port = 0);
+
+	/// \brief Returns true if connection was established successfully
+	///
+	/// \return true if connection was established successfully
+	bool connected() const;
+
+	/// \brief Returns the number of rows in a table
+	///
+	/// \param table name of table whose rows you want counted
+	///
+	/// This is syntactic sugar for a \c SELECT \c COUNT(*)
+	/// \c FROM \c table SQL query.
+	ulonglong count_rows(const std::string& table);
+
+	/// \brief Ask the database server to create a database
+	///
+	/// \param db name of database to create
+	///
+	/// \return true if database was created successfully
+	bool create_db(const std::string& db);
+
+	/// \brief Drop the connection to the database server
+	void disconnect();
+
+	/// \brief Returns a reference to the current database driver
+	///
+	/// \internal This exists mostly for the benefit of Query, Result
+	/// and ResUse.  If there is something you want to use in the
+	/// DBDriver interface, look for something similar in one of these
+	/// classes instead.  If you still can't find it, send a message to
+	/// the mailing list asking about it.  Unless you're doing something
+	/// very low-level, there should never be a reason to use the 
+	/// driver directly.
+	DBDriver* driver() { return driver_; }
+
+	/// \brief Asks the database server to drop (destroy) a database
+	///
+	/// \param db name of database to destroy
+	///
+	/// \return true if database was dropped successfully
+	bool drop_db(const std::string& db);
+
+	/// \brief Return last error number associated with this
+	/// connection
+	int errnum();
+
+	/// \brief Return error message for last error associated with
+	/// this connection.
+	///
+	/// Returns either a MySQL++-specific error message if one exists,
+	/// or one from the current database driver otherwise.
+	const char* error() const;
+
+	/// \brief Get information about the IPC connection to the
+	/// database server
+	///
+	/// String contains info about type of connection (e.g. TCP/IP,
+	/// named pipe, Unix socket...) and the server hostname.
+	std::string ipc_info() const;
+
+	/// \brief Kill a database server thread
+	///
+	/// \param tid ID of thread to kill
+    ///
+    /// \see thread_id()
+	bool kill(unsigned long tid) const;
+
+	/// \brief Test whether any error has occurred within the object.
+	///
+	/// Allows the object to be used in bool context, like this:
+	///
+	/// \code
+	///	Connection conn;
+	///	.... use conn
+	///	if (conn) {
+	///	    ... nothing bad has happened since last successful use
+	///	}
+	///	else {
+	///	    ... some error has occurred
+	///	}
+	/// \endcode
+	///
+	/// Prior to MySQL++ v3, the object was always falsy when we
+	/// weren't connected.  Now a true return simply indicates a lack of
+	/// errors.  If you've been using this to test for whether the
+	/// connection is still up, you need to call connected() instead.
+	operator private_bool_type() const
+	{
+		return copacetic_ ? &Connection::copacetic_ : 0;
+	}
+
+	/// \brief Copy an existing Connection object's state into this
+	/// object.
+	Connection& operator=(const Connection& rhs);
+
+	/// \brief "Pings" the database server
+	///
+	/// \retval true if server is responding
+	/// \retval false if either we already know the connection is down
+	/// and cannot re-establish it, or if the server did not respond to
+	/// the ping and we could not re-establish the connection.
+	bool ping();
+
+	/// \brief Returns version number of the protocol the database
+	/// driver uses to communicate with the server.
+	int protocol_version() const;
+
+	/// \brief Return a new query object.
+	///
+	/// The returned query object is tied to this connection object,
+	/// so when you call a method like
+	/// \link Query::execute() execute() \endlink
+	/// on that object, the query is sent to the server this object
+	/// is connected to.
+	///
+	/// \param qstr an optional query string for populating the
+	/// new Query object
+	Query query(const char* qstr = 0);
+
+	/// \brief Return a new query object
+	///
+	/// \param qstr initial query string
+	Query query(const std::string& qstr);
+
+	/// \brief Change to a different database managed by the
+	/// database server we are connected to.
+	///
+	/// \param db database to switch to
+	///
+	/// \retval true if we changed databases successfully
+	bool select_db(const std::string& db);
+
+	/// \brief Get the database server's version string
+	std::string server_version() const;
+
+	/// \brief Sets a connection option
+	///
+	/// \param o pointer to any derivative of Option allocated on
+	/// the heap
+	///
+	/// Objects passed to this method and successfully set will be
+	/// released when this Connection object is destroyed.  If an error
+	/// occurs while setting the option the object will be deleted
+	/// immediately.
+	///
+	/// Because there are so many Option subclasses, the actual effect
+	/// of this function has a wide range.  This mechanism abstracts
+	/// away many things that are unrelated down at the database driver
+	/// level, hiding them behind a coherent, type-safe interface.
+	///
+	/// The rules about which options can be set, when, are up to the
+	/// underlying database driver.  Some must be set before the
+	/// connection is established because they can only be used during
+	/// that connection setup process.  Others can be set at any time
+	/// after the connection comes up.  If you get it wrong, you'll get
+	/// a BadOption exception.
+	///
+	/// \retval true if option was successfully set
+	bool set_option(Option* o);
+
+	/// \brief Ask database server to shut down.
+	bool shutdown();
+
+	/// \brief Returns information about database server's status
+	std::string server_status() const;
+
+	/// \brief Returns true if both MySQL++ and database driver we're
+	/// using were compiled with thread awareness.
+	static bool thread_aware();
+
+	/// \brief Tells the underlying database driver that this thread
+	/// is done using the library.
+	static void thread_end();
+
+	/// \brief Returns the database server's thread ID for this connection
+	///
+	/// This has nothing to do with threading on the client side.  The
+	/// only thing you can do with this value is pass it to kill().
+	unsigned long thread_id();
+
+	/// \brief Tells the underlying database driver that the current
+	/// thread is now using its services.
+	///
+	/// It's not necessary to call this from the thread that creates
+	/// the connection as it's done automatically.  This method exists
+	/// for times when multiple threads may use this object; it allows
+	/// the underlying database driver to set up any per-thread data
+	/// structures it needs.
+	///
+	/// The MySQL++ user manual's <a href="../userman/threads.html">chapter
+	/// on threads</a> details two major strategies for dealing with
+	/// connections in the face of threads.  The Connection-per-thread
+	/// option frees you from ever having to call this method.  The
+	/// other documented strategy is to use ConnectionPool, which opens
+	/// the possibility for one thread to create a connection that
+	/// another uses, so you do need to call this method in that case,
+	/// or with any other similar strategy.
+	///
+	/// \retval True if there was no problem
+	static bool thread_start();
+
+protected:
+	/// \brief Build an error message in the standard form used whenever
+	/// one of the methods can't succeed because we're not connected to
+	/// the database server.
+	void build_error_message(const char* core);
+
+	/// \brief Establish a new connection as a copy of an existing one
+	///
+	/// \param other the connection to copy
+	void copy(const Connection& other);
+
+	/// \brief Extract elements from the server parameter in formats
+	/// suitable for passing to DBDriver::connect().
+	bool parse_ipc_method(const char* server, std::string& host,
+			unsigned int& port, std::string& socket_name);
+
+	//// Subclass data
+	mutable std::string error_message_;	///< MySQL++ specific error, if any
+
+private:
+	DBDriver* driver_;
+	bool copacetic_;
+};
+
+
+} // end namespace mysqlpp
+
+// Not strictly required, but bring in our specialization subclasses
+#include "tcp_connection.h"
+#include "uds_connection.h"
+#include "wnp_connection.h"
+
+#endif // !defined(MYSQLPP_CONNECTION_H)
+

ADDED   lib/cpool.cpp
Index: lib/cpool.cpp
==================================================================
--- /dev/null
+++ lib/cpool.cpp
@@ -0,0 +1,161 @@
+/***********************************************************************
+ cpool.cpp - Implements the ConnectionPool class.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc. and
+ (c) 2007 by Jonathan Wakely.  Others may also hold copyrights on
+ code in this file.  See the CREDITS file in the top directory of
+ the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "cpool.h"
+
+#include "connection.h"
+
+#include <algorithm>
+#include <functional>
+
+namespace mysqlpp {
+
+
+/// \brief Functor to test whether a given ConnectionInfo object is
+/// "too old".
+///
+/// \internal This is a template only because ConnectionInfo is private.
+/// Making it a template means the private type is only used at the point
+/// of instantiation, where it is accessible.
+
+template <typename ConnInfoT>
+class TooOld : std::unary_function<ConnInfoT, bool>
+{
+public:
+#if !defined(DOXYGEN_IGNORE)
+	TooOld(unsigned int tmax) :
+	min_age_(time(0) - tmax)
+	{
+	}
+
+	bool operator()(const ConnInfoT& conn_info) const
+	{
+		return !conn_info.in_use && conn_info.last_used <= min_age_;
+	}
+
+#endif
+private:
+	time_t min_age_;
+};
+
+
+
+//// clear /////////////////////////////////////////////////////////////
+// Destroy connections in the pool, either all of them (completely
+// draining the pool) or just those not currently in use.  The public
+// method shrink() is an alias for clear(false).
+
+void
+ConnectionPool::clear(bool all)
+{
+	ScopedLock lock(mutex_);	// ensure we're not interfered with
+
+	PoolIt it = pool_.begin(), doomed;
+	while (it != pool_.end()) {
+		if (all || !it->in_use) {
+			doomed = it++;
+			destroy(doomed->conn);
+			pool_.erase(doomed);
+		}
+		else {
+			++it;
+		}
+	}
+}
+
+
+//// find_mru //////////////////////////////////////////////////////////
+// Find most recently used available connection.  Uses operator< for
+// ConnectionInfo to order pool with MRU connection last.  Returns 0 if
+// there are no connections not in use.
+
+Connection*
+ConnectionPool::find_mru()
+{
+	PoolIt mru = std::max_element(pool_.begin(), pool_.end());
+	if (mru != pool_.end() && !mru->in_use) {
+		mru->in_use = true;
+		return mru->conn;
+	}
+	else {
+		return 0;
+	}
+}
+
+
+//// grab //////////////////////////////////////////////////////////////
+
+Connection*
+ConnectionPool::grab()
+{
+	ScopedLock lock(mutex_);	// ensure we're not interfered with
+	remove_old_connections();
+	if (Connection* mru = find_mru()) {
+		return mru;
+	}
+	else {
+		// No free connections, so create and return a new one.
+		pool_.push_back(ConnectionInfo(create()));
+		return pool_.back().conn;
+	}
+}
+
+
+//// release ///////////////////////////////////////////////////////////
+
+void
+ConnectionPool::release(const Connection* pc)
+{
+	ScopedLock lock(mutex_);	// ensure we're not interfered with
+
+	for (PoolIt it = pool_.begin(); it != pool_.end(); ++it) {
+		if (it->conn == pc) {
+			it->in_use = false;
+			it->last_used = time(0);
+			break;
+		}
+	}
+}
+
+
+//// remove_old_connections ////////////////////////////////////////////
+// Remove connections that were last used too long ago.
+
+void
+ConnectionPool::remove_old_connections()
+{
+	TooOld<ConnectionInfo> too_old(max_idle_time());
+
+	PoolIt it = pool_.begin();
+	while ((it = std::find_if(it, pool_.end(), too_old)) != pool_.end()) {
+		destroy(it->conn);
+		pool_.erase(it++);
+	}
+}
+
+
+} // end namespace mysqlpp
+

ADDED   lib/cpool.h
Index: lib/cpool.h
==================================================================
--- /dev/null
+++ lib/cpool.h
@@ -0,0 +1,201 @@
+/// \file cpool.h
+/// \brief Declares the ConnectionPool class.
+
+/***********************************************************************
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc. and
+ (c) 2007 by Jonathan Wakely.  Others may also hold copyrights on
+ code in this file.  See the CREDITS file in the top directory of
+ the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_CPOOL_H)
+#define MYSQLPP_CPOOL_H
+
+#include "beemutex.h"
+
+#include <list>
+
+#include <assert.h>
+#include <time.h>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class MYSQLPP_EXPORT Connection;
+#endif
+
+/// \brief Manages a pool of connections for programs that need more
+/// than one Connection object at a time, but can't predict how many
+/// they need in advance.
+///
+/// This class is useful in programs that need to make multiple
+/// simultaneous queries on the database; this requires multiple
+/// Connection objects due to a hard limitation of the underlying
+/// C API.  Connection pools are most useful in multithreaded programs,
+/// but it can be helpful to have one in a single-threaded program as
+/// well.  Sometimes it's necessary to get more data from the server
+/// while in the middle of processing data from an earlier query; this
+/// requires multiple connections.  Whether you use a pool or manage
+/// connections yourself is up to you, but realize that this class
+/// takes care of a lot of subtle details for you that aren't obvious.
+///
+/// The pool's policy for connection reuse is to always return the 
+/// \em most recently used connection that's not being used right now.
+/// This ensures that excess connections don't hang around any longer
+/// than they must.  If the pool were to return the \em least recently
+/// used connection, it would be likely to result in a large pool of
+/// sparsely used connections because we'd keep resetting the last-used 
+/// time of whichever connection is least recently used at that moment.
+
+class MYSQLPP_EXPORT ConnectionPool
+{
+public:
+	/// \brief Create empty pool
+	ConnectionPool() { }
+
+	/// \brief Destroy object
+	///
+	/// If the pool raises an assertion on destruction, it means our
+	/// subclass isn't calling clear() in its dtor as it should.
+	virtual ~ConnectionPool() { assert(empty()); }
+
+	/// \brief Returns true if pool is empty
+	bool empty() const { return pool_.empty(); }
+
+	/// \brief Grab a free connection from the pool.
+	///
+	/// This method creates a new connection if an unused one doesn't
+	/// exist, and destroys any that have remained unused for too long.
+	/// If there is more than one free connection, we return the most
+	/// recently used one; this allows older connections to die off over
+	/// time when the caller's need for connections decreases.
+	///
+	/// Do not delete the returned pointer.  This object manages the
+	/// lifetime of connection objects it creates.
+	///
+	/// \retval a pointer to the connection
+	virtual Connection* grab();
+
+	/// \brief Return a connection to the pool
+	///
+	/// Marks the connection as no longer in use.
+	///
+	/// The pool updates the last-used time of a connection only on
+	/// release, on the assumption that it was used just prior.  There's
+	/// nothing forcing you to do it this way: your code is free to
+	/// delay releasing idle connections as long as it likes.  You
+	/// want to avoid this because it will make the pool perform poorly;
+	/// if it doesn't know approximately how long a connection has
+	/// really been idle, it can't make good judgements about when to
+	/// remove it from the pool.
+	virtual void release(const Connection* pc);
+
+	/// \brief Remove all unused connections from the pool
+	void shrink() { clear(false); }
+
+protected:
+	/// \brief Drains the pool, freeing all allocated memory.
+	///
+	/// A derived class must call this in its dtor to avoid leaking all
+	/// Connection objects still in existence.  We can't do it up at
+	/// this level because this class's dtor can't call our subclass's
+	/// destroy() method.
+	///
+	/// \param all if true, remove all connections, even those in use
+	void clear(bool all = true);
+
+	/// \brief Create a new connection
+	///
+	/// Subclasses must override this.
+	///
+	/// Essentially, this method lets your code tell ConnectionPool
+	/// what server to connect to, what login parameters to use, what
+	/// connection options to enable, etc.  ConnectionPool can't know
+	/// any of this without your help.
+	///
+	/// \retval A connected Connection object
+	virtual Connection* create() = 0;
+
+	/// \brief Destroy a connection
+	///
+	/// Subclasses must override this.
+	///
+	/// This is for destroying the objects returned by create().
+	/// Because we can't know what the derived class did to create the
+	/// connection we can't reliably know how to destroy it.
+	virtual void destroy(Connection*) = 0;
+
+	/// \brief Returns the maximum number of seconds a connection is
+	/// able to remain idle before it is dropped.
+	///
+	/// Subclasses must override this as it encodes a policy issue,
+	/// something that MySQL++ can't declare by fiat.
+	///
+	/// \retval number of seconds before an idle connection is destroyed
+	/// due to lack of use
+	virtual unsigned int max_idle_time() = 0;
+
+	/// \brief Returns the current size of the internal connection pool.
+	size_t size() const { return pool_.size(); }
+
+private:
+	//// Internal types
+	struct ConnectionInfo {
+		Connection* conn;
+		time_t last_used;
+		bool in_use;
+
+		ConnectionInfo(Connection* c) :
+		conn(c),
+		last_used(time(0)),
+		in_use(true)
+		{
+		}
+
+		// Strict weak ordering for ConnectionInfo objects.
+		// 
+		// This ordering defines all in-use connections to be "less
+		// than" those not in use.  Within each group, connections
+		// less recently touched are less than those more recent.
+		bool operator<(const ConnectionInfo& rhs) const
+		{
+			const ConnectionInfo& lhs = *this;
+			return lhs.in_use == rhs.in_use ?
+					lhs.last_used < rhs.last_used :
+					lhs.in_use;
+		}
+	};
+	typedef std::list<ConnectionInfo> PoolT;
+	typedef PoolT::iterator PoolIt;
+
+	//// Internal support functions
+	Connection* find_mru();
+	void remove_old_connections();
+
+	//// Internal data
+	PoolT pool_;
+	BeecryptMutex mutex_;
+};
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_CPOOL_H)
+

ADDED   lib/custom.h
Index: lib/custom.h
==================================================================
--- /dev/null
+++ lib/custom.h
@@ -0,0 +1,34 @@
+/// \file custom.h
+/// \brief Backwards-compatibility header; loads ssqls.h
+
+/***********************************************************************
+ Copyright (c) 2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_CUSTOM_H)
+#define MYSQLPP_CUSTOM_H
+
+#warning MySQL++ header custom.h is now called ssqls.h.  Please update your code.
+#include "ssqls.h"
+
+#endif // !defined(MYSQLPP_CUSTOM_H)
+

ADDED   lib/datetime.cpp
Index: lib/datetime.cpp
==================================================================
--- /dev/null
+++ lib/datetime.cpp
@@ -0,0 +1,323 @@
+/***********************************************************************
+ datetime.cpp - Implements date and time classes compatible with MySQL's
+	various date and time column types.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "common.h"
+
+#include "datetime.h"
+#include "stream2string.h"
+
+#include <iomanip>
+
+#include <stdlib.h>
+#include <time.h>
+
+using namespace std;
+
+namespace mysqlpp {
+
+static void
+safe_localtime(struct tm* ptm, const time_t t)
+{
+#if defined(MYSQLPP_HAVE_LOCALTIME_S)
+	// common.h detected localtime_s() from native RTL of VC++ 2005 and up
+	localtime_s(ptm, &t);
+#elif defined(HAVE_LOCALTIME_R)
+	// autoconf detected POSIX's localtime_r() on this system
+	localtime_r(&t, ptm);
+#else
+	// No explicitly thread-safe localtime() replacement found.  This
+	// may still be thread-safe, as some C libraries take special steps
+	// within localtime() to get thread safety, such as TLS.
+	memcpy(ptm, localtime(&t), sizeof(tm));
+#endif
+}
+
+
+std::ostream& operator <<(std::ostream& os, const Date& d)
+{
+	char fill = os.fill('0');
+	ios::fmtflags flags = os.setf(ios::right);
+	os		<< setw(4) << d.year() << '-' 
+			<< setw(2) << static_cast<int>(d.month()) << '-'
+			<< setw(2) << static_cast<int>(d.day());
+	os.flags(flags);
+	os.fill(fill);
+	return os;
+}
+
+
+std::ostream& operator <<(std::ostream& os, const Time& t)
+{
+	char fill = os.fill('0');
+	ios::fmtflags flags = os.setf(ios::right);
+	os		<< setw(2) << static_cast<int>(t.hour()) << ':' 
+			<< setw(2) << static_cast<int>(t.minute()) << ':'
+			<< setw(2) << static_cast<int>(t.second());
+	os.flags(flags);
+	os.fill(fill);
+	return os;
+}
+
+
+std::ostream& operator <<(std::ostream& os, const DateTime& dt)
+{
+	if (dt.is_now()) {
+		return os << "NOW()";
+	}
+	else {
+		operator <<(os, Date(dt));
+		os << ' ';
+		return operator <<(os, Time(dt));
+	}
+}
+
+
+Date::Date(time_t t)
+{
+	struct tm tm;
+	safe_localtime(&tm, t);
+
+	year_ = tm.tm_year + 1900;
+	month_ = tm.tm_mon + 1;
+	day_ = tm.tm_mday;
+}
+
+
+DateTime::DateTime(time_t t)
+{
+	struct tm tm;
+	safe_localtime(&tm, t);
+
+	year_ = tm.tm_year + 1900;
+	month_ = tm.tm_mon + 1;
+	day_ = tm.tm_mday;
+	hour_ = tm.tm_hour;
+	minute_ = tm.tm_min;
+	second_ = tm.tm_sec;
+
+	now_ = false;
+}
+
+
+Time::Time(time_t t)
+{
+	struct tm tm;
+	safe_localtime(&tm, t);
+
+	hour_ = tm.tm_hour;
+	minute_ = tm.tm_min;
+	second_ = tm.tm_sec;
+}
+
+
+const char*
+Date::convert(const char* str)
+{
+	char num[5];
+
+	num[0] = *str++;
+	num[1] = *str++;
+	num[2] = *str++;
+	num[3] = *str++;
+	num[4] = 0;
+	year_ = static_cast<unsigned short>(strtol(num, 0, 10));
+	if (*str == '-') str++;
+
+	num[0] = *str++;
+	num[1] = *str++;
+	num[2] = 0;
+	month_ = static_cast<unsigned char>(strtol(num, 0, 10));
+	if (*str == '-') str++;
+
+	num[0] = *str++;
+	num[1] = *str++;
+	num[2] = 0;
+	day_ = static_cast<unsigned char>(strtol(num, 0, 10));
+
+	return str;
+}
+
+
+const char*
+Time::convert(const char* str)
+{
+	char num[5];
+
+	num[0] = *str++;
+	num[1] = *str++;
+	num[2] = 0;
+	hour_ = static_cast<unsigned char>(strtol(num,0,10));
+	if (*str == ':') str++;
+
+	num[0] = *str++;
+	num[1] = *str++;
+	num[2] = 0;
+	minute_ = static_cast<unsigned char>(strtol(num,0,10));
+	if (*str == ':') str++;
+
+	num[0] = *str++;
+	num[1] = *str++;
+	num[2] = 0;
+	second_ = static_cast<unsigned char>(strtol(num,0,10));
+
+	return str;
+}
+
+
+const char*
+DateTime::convert(const char* str)
+{
+	Date d;
+	str = d.convert(str);
+	year_ = d.year();
+	month_ = d.month();
+	day_ = d.day();
+	
+	if (*str == ' ') ++str;
+
+	Time t;
+	str = t.convert(str);
+	hour_ = t.hour();
+	minute_ = t.minute();
+	second_ = t.second();
+
+	now_ = false;
+	
+	return str;
+}
+
+
+int
+Date::compare(const Date& other) const
+{
+	if (year_ != other.year_) return year_ - other.year_;
+	if (month_ != other.month_) return month_ - other.month_;
+	return day_ - other.day_;
+}
+
+
+int
+Time::compare(const Time& other) const
+{
+	if (hour_ != other.hour_) return hour_ - other.hour_;
+	if (minute_ != other.minute_) return minute_ - other.minute_;
+	return second_ - other.second_;
+}
+
+
+int
+DateTime::compare(const DateTime& other) const
+{
+	if (now_ && other.now_) {
+		return 0;
+	}
+	else {
+		Date d(*this), od(other);
+		Time t(*this), ot(other);
+
+		if (int x = d.compare(od)) {
+			return x;
+		}
+		else {
+			return t.compare(ot);
+		}
+	}
+}
+
+
+Date::operator std::string() const
+{
+	return stream2string(*this);
+}
+
+
+DateTime::operator std::string() const
+{
+	return stream2string(*this);
+}
+
+
+Time::operator std::string() const
+{
+	return stream2string(*this);
+}
+
+
+Date::operator time_t() const
+{
+	struct tm tm;
+	safe_localtime(&tm, time(0));
+
+	tm.tm_mday = day_;
+	tm.tm_mon = month_ - 1;
+	tm.tm_year = year_ - 1900;
+	tm.tm_isdst = -1;
+
+	return mktime(&tm);
+}
+
+
+DateTime::operator time_t() const
+{
+	if (now_) {
+		// Many factors combine to make it almost impossible for this
+		// case to return the same value as you'd get if you used this
+		// in a query.  But, you gotta better idea than to return the
+		// current time for an object initialized with the value "now"?
+		return time(0);
+	}
+	else {
+		struct tm tm;
+		tm.tm_sec = second_;
+		tm.tm_min = minute_;
+		tm.tm_hour = hour_;
+		tm.tm_mday = day_;
+		tm.tm_mon = month_ - 1;
+		tm.tm_year = year_ - 1900;
+		tm.tm_isdst = -1;
+
+		return mktime(&tm);
+	}
+}
+
+
+Time::operator time_t() const
+{
+	struct tm tm;
+	safe_localtime(&tm, time(0));
+
+	tm.tm_sec = second_;
+	tm.tm_min = minute_;
+	tm.tm_hour = hour_;
+	tm.tm_isdst = -1;
+
+	return mktime(&tm);
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/datetime.h
Index: lib/datetime.h
==================================================================
--- /dev/null
+++ lib/datetime.h
@@ -0,0 +1,449 @@
+/// \file datetime.h
+/// \brief Declares classes to add SQL-compatible date and time
+/// types to C++'s type system.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_DATETIME_H)
+#define MYSQLPP_DATETIME_H
+
+#include "common.h"
+
+#include "comparable.h"
+
+#include <string>
+#include <iostream>
+
+namespace mysqlpp {
+
+/// \brief C++ form of SQL's DATETIME type.
+///
+/// This object exists primarily for conversion purposes.  You can
+/// initialize it in several different ways, and then convert the object
+/// to SQL string form, extract the individual y/m/d h:m:s values,
+/// convert it to C's time_t, etc.
+
+class MYSQLPP_EXPORT DateTime : public Comparable<DateTime>
+{
+public:
+	/// \brief Default constructor
+	DateTime() :
+	Comparable<DateTime>(),
+	year_(0),
+	month_(0),
+	day_(0),
+	hour_(0),
+	minute_(0),
+	second_(0),
+	now_(true)
+	{
+	}
+
+	/// \brief Initialize object from discrete y/m/d h:m:s values.
+	///
+	/// \param y year_
+	/// \param mon month_
+	/// \param d day_ of month_
+	/// \param h hour_
+	/// \param min minute_
+	/// \param s second_
+	DateTime(unsigned short y, unsigned char mon, unsigned char d,
+			unsigned char h, unsigned char min, unsigned char s) :
+	Comparable<DateTime>(),
+	year_(y),
+	month_(mon),
+	day_(d),
+	hour_(h),
+	minute_(min),
+	second_(s),
+	now_(false)
+	{
+	}
+	
+	/// \brief Initialize object as a copy of another Date
+	DateTime(const DateTime& other) :
+	Comparable<DateTime>(),
+	year_(other.year_),
+	month_(other.month_),
+	day_(other.day_),
+	hour_(other.hour_),
+	minute_(other.minute_),
+	second_(other.second_),
+	now_(other.now_)
+	{
+	}
+
+	/// \brief Initialize object from a C string containing a SQL
+	/// date-and-time string
+	///
+	/// String must be in the HH:MM:SS format.  It doesn't have to be
+	/// zero-padded.
+	explicit DateTime(const char* str) { convert(str); }
+	
+	/// \brief Initialize object from a C++ string containing a
+	/// SQL date-and-time string
+	///
+	/// This works with any stringish class that declares a c_str()
+	/// member function: std::string, mysqlpp::String...
+	///
+	/// \sa DateTime(const char*)
+	template <class Str>
+	explicit DateTime(const Str& str)
+	{
+		convert(str.c_str());
+	}
+
+	/// \brief Initialize object from a \c time_t
+	explicit DateTime(time_t t);
+
+	/// \brief Compare this object to another.
+	///
+	/// Returns < 0 if this object is before the other, 0 of they are
+	/// equal, and > 0 if this object is after the other.
+	int compare(const DateTime& other) const;
+
+	/// \brief Parse a SQL date and time string into this object.
+	const char* convert(const char*);
+
+	/// \brief Get the date/time value's day part, 1-31
+	unsigned char day() const { return day_; }
+
+	/// \brief Change the date/time value's day part, 1-31
+	void day(unsigned char d) { day_ = d; now_ = false; }
+
+	/// \brief Get the date/time value's hour part, 0-23
+	unsigned char hour() const { return hour_; }
+
+	/// \brief Change the date/time value's hour part, 0-23
+	void hour(unsigned char h) { hour_ = h; now_ = false; }
+
+	/// \brief Returns true if object will evaluate to SQL "NOW()" on
+	/// conversion to string.
+	bool is_now() const { return now_; }
+
+	/// \brief Get the date/time value's minute part, 0-59
+	unsigned char minute() const { return minute_; }
+
+	/// \brief Change the date/time value's minute part, 0-59
+	void minute(unsigned char m) { minute_ = m; now_ = false; }
+
+	/// \brief Get the date/time value's month part, 1-12
+	unsigned char month() const { return month_; }
+
+	/// \brief Change the date/time value's month part, 1-12
+	void month(unsigned char m) { month_ = m; now_ = false; }
+
+	/// \brief Factory to create an object instance that will convert
+	/// to SQL "NOW()" on insertion into a query
+	///
+	/// This is just syntactic sugar around the default ctor
+	static DateTime now() { return DateTime(); }
+
+	/// \brief Convert to std::string
+	operator std::string() const;
+
+	/// \brief Convert to time_t
+	operator time_t() const;
+
+	/// \brief Get the date/time value's second part, 0-59
+	unsigned char second() const { return second_; }
+
+	/// \brief Change the date/time value's second part, 0-59
+	void second(unsigned char s) { second_ = s; now_ = false; }
+
+	/// \brief Return our value in std::string form
+	std::string str() const { return *this; }
+
+	/// \brief Get the date/time value's year part
+	///
+	/// There's no trickery here like in some date/time implementations
+	/// where you have to add 1900 or something like that.
+	unsigned short year() const { return year_; }
+
+	/// \brief Change the date/time value's year part
+	///
+	/// Pass the year value normally; we don't optimize the value by
+	/// subtracting 1900 like some other date/time implementations.
+	void year(unsigned short y) { year_ = y; now_ = false; }
+
+private:
+	unsigned short year_;	///< the year, as a simple integer
+	unsigned char month_;	///< the month, 1-12
+	unsigned char day_;		///< the day, 1-31
+	unsigned char hour_;	///< the hour, 0-23
+	unsigned char minute_;	///< the minute, 0-59
+	unsigned char second_;	///< the second, 0-59
+
+	bool now_;	///< true if object not initialized with explicit value
+};
+
+
+/// \brief Inserts a DateTime object into a C++ stream in a
+/// SQL-compatible format.
+///
+/// The date and time are inserted into the stream, in that order,
+/// with a space between them.
+///
+/// \param os stream to insert date and time into
+/// \param dt date/time object to insert into stream
+MYSQLPP_EXPORT std::ostream& operator <<(std::ostream& os,
+		const DateTime& dt);
+
+
+/// \brief C++ form of SQL's DATE type.
+///
+/// Objects of this class can be inserted into streams, and
+/// initialized from SQL DATE strings.
+class MYSQLPP_EXPORT Date : public Comparable<Date>
+{
+public:
+	/// \brief Default constructor
+	Date() : year_(0), month_(0), day_(0) { }
+
+	/// \brief Initialize object
+	Date(unsigned short y, unsigned char m, unsigned char d) :
+	Comparable<Date>(),
+	year_(y),
+	month_(m),
+	day_(d)
+	{
+	}
+	
+	/// \brief Initialize object as a copy of another Date
+	Date(const Date& other) :
+	Comparable<Date>(),
+	year_(other.year_),
+	month_(other.month_),
+	day_(other.day_)
+	{
+	}
+
+	/// \brief Initialize object from date part of date/time object
+	Date(const DateTime& other) :
+	Comparable<Date>(),
+	year_(other.year()),
+	month_(other.month()),
+	day_(other.day())
+	{
+	}
+
+	/// \brief Initialize object from a C string containing a date
+	///
+	/// String must be in the YYYY-MM-DD format.  It doesn't have to be
+	/// zero-padded.
+	explicit Date(const char* str) { convert(str); }
+	
+	/// \brief Initialize object from a C++ string containing a date
+	///
+	/// This works with any stringish class that declares a c_str()
+	/// member function: std::string, mysqlpp::String...
+	///
+	/// \sa Date(const char*)
+	template <class Str>
+	explicit Date(const Str& str) { convert(str.c_str()); }
+
+	/// \brief Initialize object from a \c time_t
+	///
+	/// Naturally, we throw away the "time" part of the \c time_t.  If
+	/// you need to keep it, you want to use DateTime instead.
+	explicit Date(time_t t);
+
+	/// \brief Compare this date to another.
+	///
+	/// Returns < 0 if this date is before the other, 0 of they are
+	/// equal, and > 0 if this date is after the other.
+	int compare(const Date& other) const;
+
+	/// \brief Parse a SQL date string into this object.
+	const char* convert(const char*);
+
+	/// \brief Get the date's day part, 1-31
+	unsigned char day() const { return day_; }
+
+	/// \brief Change the date's day part, 1-31
+	void day(unsigned char d) { day_ = d; }
+
+	/// \brief Get the date's month part, 1-12
+	unsigned char month() const { return month_; }
+
+	/// \brief Change the date's month part, 1-12
+	void month(unsigned char m) { month_ = m; }
+
+	/// \brief Convert to std::string
+	operator std::string() const;
+
+	/// \brief Convert to time_t
+	///
+	/// The "time" part of the \c time_t is "now"
+	operator time_t() const;
+
+	/// \brief Return our value in std::string form
+	std::string str() const { return *this; }
+
+	/// \brief Get the date's year part
+	///
+	/// There's no trickery here like in some date implementations
+	/// where you have to add 1900 or something like that.
+	unsigned short year() const { return year_; }
+
+	/// \brief Change the date's year part
+	///
+	/// Pass the year value normally; we don't optimize the value by
+	/// subtracting 1900 like some other date implementations.
+	void year(unsigned short y) { year_ = y; }
+
+private:
+	unsigned short year_;	///< the year, as a simple integer
+	unsigned char month_;	///< the month, 1-12
+	unsigned char day_;		///< the day, 1-31
+};
+
+/// \brief Inserts a Date object into a C++ stream
+///
+/// The format is YYYY-MM-DD, zero-padded.
+///
+/// \param os stream to insert date into
+/// \param d date to insert into stream
+MYSQLPP_EXPORT std::ostream& operator <<(std::ostream& os,
+		const Date& d);
+
+
+/// \brief C++ form of SQL's TIME type.
+///
+/// Objects of this class can be inserted into streams, and
+/// initialized from SQL TIME strings.
+class MYSQLPP_EXPORT Time : public Comparable<Time>
+{
+public:
+	/// \brief Default constructor
+	Time() : hour_(0), minute_(0), second_(0) { }
+
+	/// \brief Initialize object
+	Time(unsigned char h, unsigned char m, unsigned char s) :
+	hour_(h),
+	minute_(m),
+	second_(s)
+	{
+	}
+
+	/// \brief Initialize object as a copy of another Time
+	Time(const Time& other) :
+	Comparable<Time>(),
+	hour_(other.hour_),
+	minute_(other.minute_),
+	second_(other.second_)
+	{
+	}
+
+	/// \brief Initialize object from time part of date/time object
+	Time(const DateTime& other) :
+	Comparable<Time>(),
+	hour_(other.hour()),
+	minute_(other.minute()),
+	second_(other.second())
+	{
+	}
+
+	/// \brief Initialize object from a C string containing a SQL
+	/// time string
+	///
+	/// String must be in the HH:MM:SS format.  It doesn't have to be
+	/// zero-padded.
+	explicit Time(const char* str) { convert(str); }
+
+	/// \brief Initialize object from a C++ string containing a
+	/// SQL time string
+	///
+	/// This works with any stringish class that declares a c_str()
+	/// member function: std::string, mysqlpp::String...
+	///
+	/// \sa Time(const char*)
+	template <class Str>
+	explicit Time(const Str& str) { convert(str.c_str()); }
+
+	/// \brief Initialize object from a \c time_t
+	///
+	/// Naturally, we throw away the "date" part of the \c time_t.  If
+	/// you need to keep it, you want to use DateTime instead.
+	explicit Time(time_t t);
+
+	/// \brief Compare this time to another.
+	///
+	/// Returns < 0 if this time is before the other, 0 of they are
+	/// equal, and > 0 if this time is after the other.
+	int compare(const Time& other) const;
+
+	/// \brief Parse a SQL time string into this object.
+	const char* convert(const char*);
+
+	/// \brief Get the time's hour part, 0-23
+	unsigned char hour() const { return hour_; }
+
+	/// \brief Change the time's hour part, 0-23
+	void hour(unsigned char h) { hour_ = h; }
+
+	/// \brief Get the time's minute part, 0-59
+	unsigned char minute() const { return minute_; }
+
+	/// \brief Change the time's minute part, 0-59
+	void minute(unsigned char m) { minute_ = m; }
+
+	/// Convert to std::string
+	operator std::string() const;
+
+	/// \brief Convert to time_t
+	///
+	/// The "date" part of the \c time_t is "today"
+	operator time_t() const;
+
+	/// \brief Get the time's second part, 0-59
+	unsigned char second() const { return second_; }
+
+	/// \brief Change the time's second part, 0-59
+	void second(unsigned char s) { second_ = s; }
+
+	/// Return our value in std::string form
+	std::string str() const { return *this; }
+
+private:
+	unsigned char hour_;	///< the hour, 0-23
+	unsigned char minute_;	///< the minute, 0-59
+	unsigned char second_;	///< the second, 0-59
+};
+
+/// \brief Inserts a Time object into a C++ stream in a SQL-compatible
+/// format.
+///
+/// The format is HH:MM:SS, zero-padded.
+///
+/// \param os stream to insert time into
+/// \param t time to insert into stream
+MYSQLPP_EXPORT std::ostream& operator <<(std::ostream& os,
+		const Time& t);
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_DATETIME_H)

ADDED   lib/dbdriver.cpp
Index: lib/dbdriver.cpp
==================================================================
--- /dev/null
+++ lib/dbdriver.cpp
@@ -0,0 +1,249 @@
+/***********************************************************************
+ dbdriver.cpp - Implements the DBDriver class.
+
+ Copyright (c) 2005-2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "dbdriver.h"
+
+#include "exceptions.h"
+
+#include <sstream>
+#include <memory>
+
+// An argument was added to mysql_shutdown() in MySQL 4.1.3 and 5.0.1.
+#if ((MYSQL_VERSION_ID >= 40103) && (MYSQL_VERSION_ID <= 49999)) || (MYSQL_VERSION_ID >= 50001)
+#	define SHUTDOWN_ARG ,SHUTDOWN_DEFAULT
+#else
+#	define SHUTDOWN_ARG
+#endif
+
+using namespace std;
+
+namespace mysqlpp {
+
+DBDriver::DBDriver() :
+is_connected_(false)
+{
+	mysql_init(&mysql_);
+}
+
+
+DBDriver::DBDriver(const DBDriver& other) :
+is_connected_(false)
+{
+	copy(other);
+}
+
+
+DBDriver::~DBDriver()
+{
+	if (connected()) {
+		disconnect();
+	}
+
+	OptionList::const_iterator it;
+	for (it = applied_options_.begin(); it != applied_options_.end(); ++it) {
+		delete *it;
+	}
+}
+
+
+bool
+DBDriver::connect(const char* host, const char* socket_name,
+		unsigned int port, const char* db, const char* user,
+		const char* password)
+{
+	// Drop previous connection, if any
+	if (connected()) {
+		disconnect();
+	}
+
+	// Set defaults for connection options.  User can override these
+	// by calling set_option() before connect().
+	set_option_default(new ReadDefaultFileOption("my"));
+
+	// Establish the connection
+	return is_connected_ =
+			mysql_real_connect(&mysql_, host, user, password, db,
+			port, socket_name, mysql_.client_flag);
+}
+
+
+bool
+DBDriver::connect(const MYSQL& other)
+{
+	// Drop previous connection, if any
+	if (connected()) {
+		disconnect();
+	}
+
+	// Set defaults for connection options.  User can override these
+	// by calling set_option() before connect().
+	set_option_default(new ReadDefaultFileOption("my"));
+
+	// Establish the connection
+	return is_connected_ =
+			mysql_real_connect(&mysql_, other.host, other.user,
+			other.passwd, other.db, other.port, other.unix_socket,
+			other.client_flag);
+}
+
+
+void
+DBDriver::copy(const DBDriver& other)
+{
+	if (other.connected()) {
+		connect(other.mysql_);
+	}
+	else {
+		is_connected_ = false;
+	}
+}
+
+
+void
+DBDriver::disconnect()
+{
+	mysql_close(&mysql_);
+	is_connected_ = false;
+}
+
+
+bool
+DBDriver::enable_ssl(const char* key, const char* cert,
+		const char* ca, const char* capath, const char* cipher)
+{
+#if defined(HAVE_MYSQL_SSL_SET)
+	return mysql_ssl_set(&mysql_, key, cert, ca, capath, cipher) == 0;
+#else
+	return false;
+#endif
+}
+
+
+DBDriver&
+DBDriver::operator=(const DBDriver& rhs)
+{
+	copy(rhs);
+	return *this;
+}
+
+
+string
+DBDriver::query_info()
+{
+	const char* i = mysql_info(&mysql_);
+	return i ? string(i) : string();
+}
+
+
+bool
+DBDriver::set_option(unsigned int o, bool arg)
+{
+	// If we get through this loop and n is 1, only one bit is set in
+	// the option value, which is as it should be.
+	int n = o;
+	while (n && ((n & 1) == 0)) {
+		n >>= 1;
+	}
+	
+	if ((n == 1) && 
+			(o >= CLIENT_LONG_PASSWORD) && 
+#if MYSQL_VERSION_ID > 40000	// highest flag value varies by version
+			(o <= CLIENT_MULTI_RESULTS)
+#else
+			(o <= CLIENT_TRANSACTIONS)
+#endif
+			) {
+		// Option value seems sane, so go ahead and set/clear the flag
+		if (arg) {
+			mysql_.client_flag |= o;
+		}
+		else {
+			mysql_.client_flag &= ~o;
+		}
+
+		return true;
+	}
+	else {
+		// Option value is outside the range we understand, or caller
+		// erroneously passed a value with multiple bits set.
+		return false;
+	}
+}
+
+
+std::string
+DBDriver::set_option(Option* o)
+{
+	std::ostringstream os;
+	std::auto_ptr<Option> cleanup(o);
+
+	switch (o->set(this)) {
+		case Option::err_NONE:
+			applied_options_.push_back(o);
+			cleanup.release();
+			break;
+
+		case Option::err_api_limit:
+			os << "Option not supported by database driver v" <<
+					client_version();
+			throw BadOption(os.str(), typeid(*o)); // mandatory throw!
+
+		case Option::err_api_reject:
+			os << "Database driver failed to set option";
+			break;
+
+		case Option::err_connected:
+			os << "Option can only be set before connection is established";
+			break;
+	}
+
+	return os.str();
+}
+
+
+bool
+DBDriver::shutdown()
+{
+	return mysql_shutdown(&mysql_ SHUTDOWN_ARG);
+}
+
+
+bool
+DBDriver::thread_aware()
+{
+#if defined(MYSQLPP_PLATFORM_WINDOWS) || defined(HAVE_PTHREAD) || defined(HAVE_SYNCH_H)
+	// Okay, good, MySQL++ itself is thread-aware, but only return true
+	// if the underlying C API library is also thread-aware.
+	return mysql_thread_safe();
+#else
+	// MySQL++ itself isn't thread-aware, so we don't need to do any
+	// further tests.  All pieces must be thread-aware to return true.
+	return false;	
+#endif
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/dbdriver.h
Index: lib/dbdriver.h
==================================================================
--- /dev/null
+++ lib/dbdriver.h
@@ -0,0 +1,534 @@
+/// \file dbdriver.h
+/// \brief Declares the DBDriver class.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_DBDRIVER_H)
+#define MYSQLPP_DBDRIVER_H
+
+#include "common.h"
+
+#include "options.h"
+
+#include <typeinfo>
+
+#include <limits.h>
+
+namespace mysqlpp {
+
+/// \brief Provides a thin abstraction layer over the underlying database 
+/// client library.
+///
+/// This class does as little as possible to adapt between its public
+/// interface and the interface required by the underlying C API.  That
+/// is, in fact, its only mission.  The high-level interfaces indended
+/// for use by MySQL++ users are in Connection, Query, Result, and
+/// ResUse, all of which delegate the actual database communication to
+/// an object of this type, created by Connection.  If you really need
+/// access to the low-level database driver, get it via
+/// Connection::driver(); don't create DBDriver objects directly.
+///
+/// Currently this is a concrete class for wrapping the MySQL C API.
+/// In the future, it may be turned into an abstract base class, with
+/// subclasses for different database server types.
+
+class DBDriver
+{
+public:
+	/// \brief Result code returned by next_result()
+	enum nr_code {
+		nr_more_results,	///< success, with more results to come
+		nr_last_result,		///< success, last result received
+		nr_error,			///< problem retrieving next result
+		nr_not_supported	///< this C API doesn't support "next result"
+	};
+
+	/// \brief Create object
+	DBDriver();
+
+	/// \brief Duplicate an existing driver
+	///
+	/// \param other existing DBDriver object
+	///
+	/// This establishes a new database server connection with the same
+	/// parameters as the other driver's.
+	DBDriver(const DBDriver& other);
+
+	/// \brief Destroy object
+	virtual ~DBDriver();
+
+	/// \brief Return the number of rows affected by the last query
+	///
+	/// Wraps \c mysql_affected_rows() in the MySQL C API.
+	ulonglong affected_rows() { return mysql_affected_rows(&mysql_); }
+
+	/// \brief Get database client library version
+	///
+	/// Wraps \c mysql_get_client_info() in the MySQL C API.
+	std::string client_version() const { return mysql_get_client_info(); }
+
+	/// \brief Establish a new connection using the same parameters as
+	/// an existing connection.
+	///
+	/// \param mysql existing MySQL C API connection object
+	bool connect(const MYSQL& mysql);
+
+	/// \brief Connect to database server
+	///
+	/// If you call this method on an object that is already connected
+	/// to a database server, the previous connection is dropped and a
+	/// new connection is established.
+	virtual bool connect(const char* host, const char* socket_name,
+			unsigned int port, const char* db, const char* user,
+			const char* password);
+
+	/// \brief Return true if we have an active connection to the
+	/// database server.
+	///
+	/// This does not actually check whether the connection is viable,
+	/// it just indicates whether there was previously a successful
+	/// connect() call and no disconnect().  Call ping() to actually
+	/// test the connection's viability.
+	bool connected() const { return is_connected_; }
+
+	/// \brief Establish a new connection as a copy of an existing one
+	///
+	/// \param other the connection to copy
+	void copy(const DBDriver& other);
+
+	/// \brief Ask the database server to create a database
+	///
+	/// \param db name of database to create
+	///
+	/// \return true if database was created successfully
+	bool create_db(const char* db) const;
+
+	/// \brief Seeks to a particualr row within the result set
+	///
+	/// Wraps mysql_data_seek() in MySQL C API.
+	void data_seek(MYSQL_RES* res, ulonglong offset) const
+			{ mysql_data_seek(res, offset); }
+
+	/// \brief Drop the connection to the database server
+	///
+	/// This method is protected because it should only be used within
+	/// the library.  Unless you use the default constructor, this
+	/// object should always be connected.
+	void disconnect();
+
+	/// \brief Drop a database
+	///
+	/// \param db name of database to destroy
+	///
+	/// \return true if database was created successfully
+	bool drop_db(const std::string& db) const;
+
+	/// \brief Enable SSL-encrypted connection.
+	///
+	/// \param key the pathname to the key file
+	/// \param cert the pathname to the certificate file
+	/// \param ca the pathname to the certificate authority file
+	/// \param capath directory that contains trusted SSL CA
+	///        certificates in pem format.
+    /// \param cipher list of allowable ciphers to use
+	///
+	/// \return False if call fails or the C API library wasn't compiled
+	/// with SSL support enabled.
+	///
+	/// Must be called before connection is established.
+	///
+	/// Wraps \c mysql_ssl_set() in MySQL C API.
+	bool enable_ssl(const char* key = 0, const char* cert = 0,
+			const char* ca = 0, const char* capath = 0,
+			const char* cipher = 0);
+
+	/// \brief Return error message for last MySQL error associated with
+	/// this connection.
+	///
+	/// Can return a MySQL++ DBDriver-specific error message if there
+	/// is one.  If not, it simply wraps \c mysql_error() in the MySQL C API.
+	const char* error() { return mysql_error(&mysql_); }
+
+	/// \brief Return last MySQL error number associated with this
+	/// connection
+	///
+	/// Wraps \c mysql_errno() in the MySQL C API.
+	int errnum() { return mysql_errno(&mysql_); }
+
+	/// \brief SQL-escapes the given string, taking into account the
+    /// default character set of the database server we're connected to.
+	///
+	/// Wraps \c mysql_real_escape_string() in the MySQL C API.
+	size_t escape_string(char* to, const char* from, size_t length)
+			{ return mysql_real_escape_string(&mysql_, to, from, length); }
+
+	/// \brief SQL-escapes the given string without reference to the 
+    /// character set of a database server.
+	///
+	/// Wraps \c mysql_escape_string() in the MySQL C API.
+	static size_t escape_string_no_conn(char* to, const char* from,
+            size_t length)
+			{ return mysql_escape_string(to, from, length); }
+
+	/// \brief Executes the given query string
+	///
+	/// Wraps \c mysql_real_query() in the MySQL C API.
+	bool execute(const char* qstr, size_t length)
+			{ return !mysql_real_query(&mysql_, qstr, length); }
+
+	/// \brief Returns the next raw C API row structure from the given
+	/// result set.
+	///
+	/// This is for "use" query result sets only.  "store" queries have
+	/// all the rows already.
+	///
+	/// Wraps \c mysql_fetch_row() in MySQL C API.
+	MYSQL_ROW fetch_row(MYSQL_RES* res) const
+			{ return mysql_fetch_row(res); }
+
+	/// \brief Returns the lengths of the fields in the current row
+	/// from a "use" query.
+	///
+	/// Wraps \c mysql_fetch_lengths() in MySQL C API.
+	const unsigned long* fetch_lengths(MYSQL_RES* res) const
+			{ return mysql_fetch_lengths(res); }
+
+	/// \brief Returns information about a particular field in a result
+	/// set
+	///
+	/// \param res result set to fetch field information for
+	/// \param i field number to fetch information for, if given
+	///
+	/// If i parameter is given, this call is like a combination of
+	/// field_seek() followed by fetch_field() without the i parameter,
+	/// which otherwise just iterates through the set of fields in the
+	/// given result set.
+	///
+	/// Wraps \c mysql_fetch_field() and mysql_fetch_field_direct() in
+	/// MySQL C API.  (Which one it uses depends on i parameter.)
+	MYSQL_FIELD* fetch_field(MYSQL_RES* res, size_t i = UINT_MAX) const
+	{
+		return i == UINT_MAX ? mysql_fetch_field(res) :
+				mysql_fetch_field_direct(res, i);
+	}
+
+	/// \brief Jumps to the given field within the result set
+	///
+	/// Wraps \c mysql_field_seek() in MySQL C API.
+	void field_seek(MYSQL_RES* res, size_t field) const
+			{ mysql_field_seek(res, field); }
+
+	/// \brief Releases memory used by a result set
+	///
+	/// Wraps \c mysql_free_result() in MySQL C API.
+	void free_result(MYSQL_RES* res) const
+			{ mysql_free_result(res); }
+
+	/// \brief Return the connection options object
+	st_mysql_options get_options() const { return mysql_.options; }
+
+	/// \brief Get information about the IPC connection to the
+	/// database server
+	///
+	/// String contains info about type of connection (e.g. TCP/IP,
+	/// named pipe, Unix socket...) and the server hostname.
+	///
+	/// Wraps \c mysql_get_host_info() in the MySQL C API.
+	std::string ipc_info() { return mysql_get_host_info(&mysql_); }
+
+	/// \brief Get ID generated for an AUTO_INCREMENT column in the
+	/// previous INSERT query.
+	///
+	/// \retval 0 if the previous query did not generate an ID.  Use
+	/// the SQL function LAST_INSERT_ID() if you need the last ID
+	/// generated by any query, not just the previous one.
+	ulonglong insert_id() { return mysql_insert_id(&mysql_); }
+
+	/// \brief Kill a MySQL server thread
+	///
+	/// \param tid ID of thread to kill
+	///
+	/// Wraps \c mysql_kill() in the MySQL C API.
+    ///
+    /// \see thread_id()
+	bool kill(unsigned long tid) { return !mysql_kill(&mysql_, tid); }
+
+	/// \brief Returns true if there are unconsumed results from the
+	/// most recent query.
+	///
+	/// Wraps \c mysql_more_results() in the MySQL C API.
+	bool more_results()
+	{
+		#if MYSQL_VERSION_ID > 41000		// only in MySQL v4.1 +
+			return mysql_more_results(&mysql_);
+		#else
+			return false;
+		#endif
+	}
+
+	/// \brief Moves to the next result set from a multi-query
+	///
+	/// \return A code indicating whether we successfully found another
+	/// result, there were no more results (but still success) or
+	/// encountered an error trying to find the next result set.
+	///
+	/// Wraps \c mysql_next_result() in the MySQL C API, with
+	/// translation of its return value from magic integers to nr_code
+	/// enum values.
+	nr_code next_result()
+	{
+		#if MYSQL_VERSION_ID > 41000		// only in MySQL v4.1 +
+			switch (mysql_next_result(&mysql_)) {
+				case 0:  return nr_more_results;
+				case -1: return nr_last_result;
+				default: return nr_error;
+			}
+		#else
+			return nr_not_supported;
+		#endif
+	}
+
+	/// \brief Returns the number of fields in the given result set
+	///
+	/// Wraps \c mysql_num_fields() in MySQL C API.
+	int num_fields(MYSQL_RES* res) const
+			{ return mysql_num_fields(res); }
+	
+	/// \brief Returns the number of rows in the given result set
+	///
+	/// Wraps \c mysql_num_rows() in MySQL C API.
+	ulonglong num_rows(MYSQL_RES* res) const
+			{ return mysql_num_rows(res); }
+
+	/// \brief "Pings" the MySQL database
+	///
+	/// This function will try to reconnect to the server if the 
+	/// connection has been dropped.  Wraps \c mysql_ping() in the MySQL C API.
+	/// 
+	/// \retval true if server is responding, regardless of whether we had
+	/// to reconnect or not
+	/// \retval false if either we already know the connection is down
+	/// and cannot re-establish it, or if the server did not respond to
+	/// the ping and we could not re-establish the connection.
+	bool ping() { return !mysql_ping(&mysql_); }
+
+	/// \brief Returns version number of MySQL protocol this connection
+	/// is using
+	///
+	/// Wraps \c mysql_get_proto_info() in the MySQL C API.
+	int protocol_version() { return mysql_get_proto_info(&mysql_); }
+
+	/// \brief Returns information about the last executed query
+	///
+	/// Wraps \c mysql_info() in the MySQL C API
+	std::string query_info();
+
+	/// \brief Asks the database server to refresh certain internal data
+	/// structures.
+	///
+	/// Wraps \c mysql_refresh() in the MySQL C API.  There is no
+	/// corresponding interface for this in higher level MySQL++ classes
+	/// because it was undocumented until recently, and it's a pretty
+	/// low-level thing.  It's designed for things like MySQL
+	/// Administrator.
+	bool refresh(unsigned options) { return !mysql_refresh(&mysql_, options); }
+
+	/// \brief Returns true if the most recent result set was empty
+	///
+	/// Wraps \c mysql_field_count() in the MySQL C API, returning true
+	/// if it returns 0.
+	bool result_empty() { return mysql_field_count(&mysql_) == 0; }
+
+	/// \brief Asks the database server to switch to a different database
+	bool select_db(const char* db) { return !mysql_select_db(&mysql_, db); }
+
+	/// \brief Get the database server's version number
+	///
+	/// Wraps \c mysql_get_server_info() in the MySQL C API.
+	std::string server_version() { return mysql_get_server_info(&mysql_); }
+
+	/// \brief Sets a connection option
+	///
+	/// This is the database-independent high-level option setting
+	/// interface that Connection::set_option() calls.  There are
+	/// several private overloads that actually implement the option
+	/// setting.
+	///
+	/// \see Connection::set_option(Option*) for commentary
+	std::string set_option(Option* o);
+
+	/// \brief Set MySQL C API connection option
+	///
+	/// \internal Wraps \c mysql_options() in C API.
+	bool set_option(mysql_option moption, const void* arg = 0)
+	{
+		return !mysql_options(&mysql_, moption,
+				static_cast<const char*>(arg));
+	}
+
+	#if MYSQL_VERSION_ID >= 40101
+	/// \brief Set MySQL C API connection option
+	///
+	/// \internal Wraps \c mysql_set_server_option() in C API.
+	bool set_option(enum_mysql_set_option msoption)
+	{
+		return !mysql_set_server_option(&mysql_, msoption);
+	}
+	#endif
+
+	/// \brief Set MySQL C API connection option
+	///
+	/// Manipulates the MYSQL.client_flag bit mask.  This allows these
+	/// flags to be treated the same way as any other connection option,
+	/// even though the C API handles them differently.
+	bool set_option(unsigned int option, bool arg);
+
+	/// \brief Same as set_option(), except that it won't override
+	/// a previously-set option.
+	std::string set_option_default(Option* o)
+	{
+		const std::type_info& ti = typeid(o);
+		for (OptionList::const_iterator it = applied_options_.begin();
+				it != applied_options_.end(); 
+				++it) {
+			if (typeid(*it) == ti) {
+				delete o;
+				return "";		// option of this type already set
+			}
+		}
+
+		return set_option(o);
+	}
+
+	/// \brief Ask database server to shut down.
+	///
+	/// User must have the "shutdown" privilege.
+	///
+	/// Wraps \c mysql_shutdown() in the MySQL C API.
+	bool shutdown();
+
+	/// \brief Returns the database server's status
+	///
+	/// String is similar to that returned by the \c mysqladmin
+	/// \c status command.  Among other things, it contains uptime 
+	/// in seconds, and the number of running threads, questions
+	/// and open tables.
+	///
+	/// Wraps \c mysql_stat() in the MySQL C API.
+	std::string server_status() { return mysql_stat(&mysql_); }
+
+	/// \brief Saves the results of the query just execute()d in memory
+	/// and returns a pointer to the MySQL C API data structure the
+	/// results are stored in.
+	///
+	/// \sa use_result()
+	///
+	/// Wraps \c mysql_store_result() in the MySQL C API.
+	MYSQL_RES* store_result() { return mysql_store_result(&mysql_); }
+
+	/// \brief Returns true if MySQL++ and the underlying MySQL C API
+	/// library were both compiled with thread awareness.
+	///
+	/// This is based in part on a MySQL C API function
+	/// mysql_thread_safe().  We deliberately don't call this wrapper
+	/// thread_safe() because it's a misleading name: linking to
+	/// thread-aware versions of the MySQL++ and C API libraries doesn't
+	/// automatically make your program "thread-safe".  See the
+	/// <a href="../userman/threads.html">chapter on threads</a> in the
+	/// user manual for more information and guidance.
+	static bool thread_aware();
+
+	/// \brief Tells the underlying MySQL C API library that this thread
+	/// is done using the library.
+	///
+	/// This exists because the MySQL C API library allocates some per-thread
+	/// memory which it doesn't release until you call this.
+	static void thread_end()
+	{
+		#if MYSQL_VERSION_ID > 40000		// only in MySQL v4.0 +
+			mysql_thread_end();
+		#endif
+	}
+
+	/// \brief Returns the MySQL server thread ID for this connection
+	///
+	/// This has nothing to do with threading on the client side. It's
+	/// a server-side thread ID, to be used with kill().
+	unsigned long thread_id() { return mysql_thread_id(&mysql_); }
+
+	/// \brief Tells the underlying C API library that the current
+	/// thread will be using the library's services.
+	///
+	/// \retval True if there was no problem
+	///
+	/// The MySQL++ user manual's <a href="../userman/threads.html">chapter
+	/// on threads</a> details two major strategies for dealing with
+	/// connections in the face of threads.  If you take the simpler
+	/// path, creating one DBDriver object per thread, it is never
+	/// necessary to call this function; the underlying C API will call it
+	/// for you when you establish the first database server connection
+	/// from that thread.  If you use a more complex connection
+	/// management strategy where it's possible for one thread to
+	/// establish a connection that another thread uses, you must call
+	/// this from each thread that can use the database before it creates
+	/// any MySQL++ objects.  If you use a DBDriverPool object, this
+	/// applies; DBDriverPool isn't smart enough to call this for you,
+	/// and the MySQL C API won't do it, either.
+	static bool thread_start()
+	{
+		#if MYSQL_VERSION_ID > 40000		// only in MySQL v4.0 +
+			return !mysql_thread_init();
+		#else
+			return false;
+		#endif
+	}
+
+	/// \brief Returns a result set from the last-executed query which
+	/// we can walk through in linear fashion, which doesn't store all
+	/// result sets in memory.
+	///
+	/// \sa store_result
+	///
+	/// Wraps \c mysql_use_result() in the MySQL C API.
+	MYSQL_RES* use_result() { return mysql_use_result(&mysql_); }
+
+private:
+	/// \brief Data type of the list of applied connection options
+	typedef std::deque<Option*> OptionList;
+
+	/// \brief Hidden assignment operator; we don't want to be copied
+	/// that way.  What would it mean?
+	DBDriver& operator=(const DBDriver&);
+
+	MYSQL mysql_;
+	bool is_connected_;
+	OptionList applied_options_;
+};
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_DBDRIVER_H)
+

ADDED   lib/exceptions.h
Index: lib/exceptions.h
==================================================================
--- /dev/null
+++ lib/exceptions.h
@@ -0,0 +1,424 @@
+/// \file exceptions.h
+/// \brief Declares the MySQL++-specific exception classes.
+///
+/// When exceptions are enabled for a given mysqlpp::OptionalExceptions
+/// derivative, any of these exceptions can be thrown on error.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_EXCEPTIONS_H)
+#define MYSQLPP_EXCEPTIONS_H
+
+#include "options.h"
+
+#include <exception>
+#include <string>
+
+namespace mysqlpp {
+
+/// \brief Base class for all MySQL++ custom exceptions
+
+class MYSQLPP_EXPORT Exception : public std::exception
+{
+public:
+	/// \brief Create exception object as copy of another
+	Exception(const Exception& e) throw() :
+	std::exception(e),
+	what_(e.what_)
+	{
+	}
+
+	/// \brief Assign another exception object's contents to this one
+	Exception& operator=(const Exception& rhs) throw()
+	{
+		what_ = rhs.what_;
+		return *this;
+	}
+
+	/// \brief Destroy exception object
+	~Exception() throw() { }
+
+	/// \brief Returns explanation of why exception was thrown
+	virtual const char* what() const throw()
+	{
+		return what_.c_str();
+	}
+
+protected:
+	/// \brief Create exception object
+	Exception(const char* w = "") throw() :
+	what_(w)
+	{
+	}
+
+	/// \brief Create exception object
+	Exception(const std::string& w) throw() :
+	what_(w)
+	{
+	}
+
+	/// \brief explanation of why exception was thrown
+	std::string what_;
+};
+
+
+/// \brief Exception thrown when a bad type conversion is attempted.
+
+class MYSQLPP_EXPORT BadConversion : public Exception
+{
+public:
+	const char* type_name;	///< name of type we tried to convert to
+	std::string data;		///< string form of data we tried to convert
+	size_t retrieved;		///< documentation needed!
+	size_t actual_size;		///< documentation needed!
+
+	/// \brief Create exception object, building error string
+	/// dynamically
+	///
+	/// \param tn type name we tried to convert to
+	/// \param d string form of data we tried to convert
+	/// \param r ??
+	/// \param a ??
+	BadConversion(const char* tn, const char* d,
+			size_t r, size_t a) :
+	Exception("Bad type conversion: \""),
+	type_name(tn),
+	data(d),
+	retrieved(r),
+	actual_size(a)
+	{
+		what_ += d ? d : "<NULL>";
+		what_ += "\" incompatible with \"";
+		what_ += tn;
+		what_ += "\" type";
+	}
+
+	/// \brief Create exception object, given completed error string
+	///
+	/// \param w the "what" error string
+	/// \param tn type name we tried to convert to
+	/// \param d string form of data we tried to convert
+	/// \param r ??
+	/// \param a ??
+	BadConversion(const std::string& w, const char* tn,
+				  const char* d, size_t r, size_t a) :
+	Exception(w),
+	type_name(tn),
+	data(d),
+	retrieved(r),
+	actual_size(a)
+	{
+	}
+
+	/// \brief Create exception object, with error string only
+	///
+	/// \param w the "what" error string
+	///
+	/// All other data members are initialize to default values
+	explicit BadConversion(const char* w = "") :
+	Exception(w),
+	type_name("unknown"),
+	data(""),
+	retrieved(0),
+	actual_size(0)
+	{
+	}
+
+	/// \brief Destroy exception
+	~BadConversion() throw() { }
+};
+
+
+/// \brief Exception thrown when a requested named field doesn't exist.
+///
+/// Thrown by Row::lookup_by_name() when you pass a field name that
+/// isn't in the result set.
+
+class MYSQLPP_EXPORT BadFieldName : public Exception
+{
+public:
+	/// \brief Create exception object
+	///
+	/// \param bad_field name of field the database server didn't like
+	explicit BadFieldName(const char* bad_field) :
+	Exception(std::string("Unknown field name: ") + bad_field)
+	{
+	}
+
+	/// \brief Destroy exception
+	~BadFieldName() throw() { }
+};
+
+
+/// \brief Exception thrown when you pass an unrecognized option to
+/// Connection::set_option().
+
+class MYSQLPP_EXPORT BadOption : public Exception
+{
+public:
+	/// \brief Create exception object, taking C string
+	explicit BadOption(const char* w, const std::type_info& ti) :
+	Exception(w),
+	ti_(ti)
+	{
+	}
+
+	/// \brief Create exception object, taking C++ string
+	explicit BadOption(const std::string& w, const std::type_info& ti) :
+	Exception(w),
+	ti_(ti)
+	{
+	}
+
+	/// \brief Return type information about the option that failed
+	///
+	/// Because each option has its own C++ type, this lets you
+	/// distinguish among BadOption exceptions programmatically.
+	const std::type_info& what_option() const { return ti_; }
+
+private:
+	const std::type_info& ti_;
+};
+
+
+/// \brief Exception thrown when not enough query parameters are
+/// provided.
+///
+/// This is used in handling template queries.
+
+class MYSQLPP_EXPORT BadParamCount : public Exception
+{
+public:
+	/// \brief Create exception object
+	explicit BadParamCount(const char* w = "") :
+	Exception(w)
+	{
+	}
+
+	/// \brief Destroy exception
+	~BadParamCount() throw() { }
+};
+
+/// \brief Exception thrown when something goes wrong in processing a
+/// "use" query.
+
+class MYSQLPP_EXPORT UseQueryError : public Exception
+{
+public:
+	/// \brief Create exception object
+	explicit UseQueryError(const char* w = "") :
+	Exception(w)
+	{
+	}
+};
+
+
+/// \brief Exception thrown when the database server encounters a problem
+/// while processing your query.
+///
+/// Unlike most other MySQL++ exceptions, which carry just an error
+/// message, this type carries an error number to preserve
+/// Connection::errnum()'s return value at the point the exception is 
+/// thrown.  We do this because when using the Transaction class, the
+/// rollback process that occurs during stack unwinding issues a query
+/// to the database server, overwriting the error value.  This rollback
+/// should always succeed, so this effect can fool code that relies on
+/// Connection::errnum() into believing that there was no error.
+///
+/// Beware that in older versions of MySQL++, this was effectively the
+/// generic exception type.  (This is most especially true in v1.7.x,
+/// but it continued to a lesser extent through the v2.x series.)  When
+/// converting old code to new versions of MySQL++, it's therefore
+/// possible to get seemingly "new" exceptions thrown, which could crash
+/// your program if you don't also catch a more generic type like
+/// mysqlpp::Exception or std::exception.
+
+class MYSQLPP_EXPORT BadQuery : public Exception
+{
+public:
+	/// \brief Create exception object
+	///
+	/// \param w explanation for why the exception was thrown
+	/// \param e the error number from the underlying database API
+	explicit BadQuery(const char* w = "", int e = 0) :
+	Exception(w), 
+	errnum_(e)
+	{
+	}
+
+	/// \brief Create exception object
+	///
+	/// \param w explanation for why the exception was thrown
+	/// \param e the error number from the underlying database API
+	explicit BadQuery(const std::string& w, int e = 0) :
+	Exception(w), 
+	errnum_(e)
+	{
+	}
+
+	/// \brief Return the error number corresponding to the error
+	/// message returned by what()
+	///
+	/// This may return the same value as Connection::errnum(), but not
+	/// always.  See the overview documentation for this class for the
+	/// reason for the difference.
+	int errnum() const { return errnum_; }
+	
+private:	
+	int	errnum_;	///< error number associated with execption
+};
+
+
+/// \brief Exception thrown when there is a problem related to the
+/// database server connection.
+///
+/// This is thrown not just on making the connection, but also on
+/// shutdown and when calling certain of Connection's methods that
+/// require a connection when there isn't one.
+
+class MYSQLPP_EXPORT ConnectionFailed : public Exception
+{
+public:
+	/// \brief Create exception object
+	///
+	/// \param w explanation for why the exception was thrown
+	/// \param e the error number from the underlying database API
+	explicit ConnectionFailed(const char* w = "", int e = 0) :
+	Exception(w),
+	errnum_(e)
+	{
+	}
+
+	/// \brief Return the error number corresponding to the error
+	/// message returned by what(), if any.
+	///
+	/// If the error number is 0, it means that the error message
+	/// doesn't come from the underlying database API, but rather from
+	/// MySQL++ itself.  This happens when an error condition is
+	/// detected up at this higher level instead of letting the
+	/// underlying database API do it.
+	int errnum() const { return errnum_; }
+	
+private:	
+	int	errnum_;	///< error number associated with execption
+};
+
+
+/// \brief Exception thrown when the program tries to select a new
+/// database and the database server refuses for some reason.
+
+class MYSQLPP_EXPORT DBSelectionFailed : public Exception
+{
+public:
+	/// \brief Create exception object
+	///
+	/// \param w explanation for why the exception was thrown
+	/// \param e the error number from the underlying database API
+	explicit DBSelectionFailed(const char* w = "", int e = 0) :
+	Exception(w),
+	errnum_(e)
+	{
+	}
+
+	/// \brief Return the error number corresponding to the error
+	/// message returned by what(), if any.
+	///
+	/// If the error number is 0, it means that the error message
+	/// doesn't come from the underlying database API, but rather from
+	/// MySQL++ itself.  This happens when an error condition is
+	/// detected up at this higher level instead of letting the
+	/// underlying database API do it.
+	int errnum() const { return errnum_; }
+	
+private:	
+	int	errnum_;	///< error number associated with execption
+};
+
+
+/// \brief Exception thrown when a BeecryptMutex object fails.
+
+class MYSQLPP_EXPORT MutexFailed : public Exception
+{
+public:
+	/// \brief Create exception object
+	explicit MutexFailed(const char* w = "lock failed") :
+	Exception(w)
+	{
+	}
+};
+
+
+/// \brief Exception thrown when you try to use an object that isn't
+/// completely initialized.
+
+class MYSQLPP_EXPORT ObjectNotInitialized : public Exception
+{
+public:
+	/// \brief Create exception object
+	explicit ObjectNotInitialized(const char* w = "") :
+	Exception(w)
+	{
+	}
+};
+
+
+/// \brief Used within MySQL++'s test harness only.
+
+class MYSQLPP_EXPORT SelfTestFailed : public Exception
+{
+public:
+	/// \brief Create exception object
+	explicit SelfTestFailed(const std::string& w) :
+	Exception(w)
+	{
+	}
+};
+
+
+/// \brief Thrown from the C++ to SQL data type conversion routine when
+/// it can't figure out how to map the type.
+///
+/// This exception is not optional.  The only alternatives when this
+/// happens are equally drastic: basically, either iterate past the
+/// end of an array (crashing the program) or call assert() to crash
+/// the program nicely.  At least this way you have some control over
+/// how your program ends.  You can even ignore the error and keep on
+/// going: this typically happens when building a SQL query, so you can
+/// handle it just the same as if the subsequent query execution failed.
+
+class MYSQLPP_EXPORT TypeLookupFailed : public Exception
+{
+public:
+	/// \brief Create exception object
+	explicit TypeLookupFailed(const std::string& w) :
+	Exception(w)
+	{
+	}
+};
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_EXCEPTIONS_H)

ADDED   lib/field.h
Index: lib/field.h
==================================================================
--- /dev/null
+++ lib/field.h
@@ -0,0 +1,157 @@
+/// \file field.h
+/// \brief Declares the Field and Fields classes.
+
+/***********************************************************************
+ Copyright (c) 2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_FIELD_H)
+#define MYSQLPP_FIELD_H
+
+#include "common.h"
+#include "type_info.h"
+
+#include <vector>
+
+namespace mysqlpp {
+
+/// \brief Class to hold information about a SQL field
+///
+/// This is a cut-down version of MYSQL_FIELD, using MySQL++ and generic
+/// C++ types instead of the C types it uses, and hiding all fields
+/// behind accessors.  It leaves out data members we have decided aren't
+/// very useful.  Given a good argument, we're willing to mirror more of
+/// the fields; we just don't want to mirror the underlying structure
+/// slavishly for no benefit.
+
+class Field
+{
+public:
+	/// \brief Create empty object
+	Field() :
+	length_(0),
+	max_length_(0),
+	flags_(0)
+	{
+	}
+
+	/// \brief Create object from C API field structure
+	Field(const MYSQL_FIELD* pf) :
+	name_(pf->name),
+	table_(pf->table),
+#if MYSQL_VERSION_ID > 40000	// only in 4.0 +
+	db_(pf->db),
+#endif
+	type_(pf->type, (pf->flags & UNSIGNED_FLAG) != 0,
+			(pf->flags & NOT_NULL_FLAG) == 0),
+	length_(pf->length),
+	max_length_(pf->max_length),
+	flags_(pf->flags)
+	{
+	}
+
+	/// \brief Create object as a copy of another Field
+	Field(const Field& other) :
+	name_(other.name_),
+	table_(other.table_),
+	db_(other.db_),
+	type_(other.type_),
+	length_(other.length_),
+	max_length_(other.max_length_),
+	flags_(other.flags_)
+	{
+	}
+
+	/// \brief Returns true if field auto-increments
+	bool auto_increment() const { return flags_ & AUTO_INCREMENT_FLAG; }
+
+	/// \brief Returns true if field is of some binary type
+	bool binary_type() const { return flags_ & BINARY_FLAG; }
+
+	/// \brief Returns true if field is of some BLOB type
+	bool blob_type() const { return flags_ & BLOB_FLAG; }
+
+	/// \brief Return the name of the database the field comes from
+	const char* db() const { return db_.c_str(); }
+
+	/// \brief Returns true if field is of an enumerated value type
+	bool enumeration() const { return flags_ & ENUM_FLAG; }
+
+	/// \brief Return the creation size of the field
+	///
+	/// This is the number of bytes the field can hold, not how much is
+	/// actually stored in the field on any particular row.
+	size_t length() const { return length_; }
+
+	/// \brief Return the maximum number of bytes stored in this field
+	/// in any of the rows in the result set we were created from.
+	size_t max_length() const { return max_length_; }
+
+	/// \brief Returns true if field is part of a key
+	bool multiple_key() const { return flags_ & MULTIPLE_KEY_FLAG; }
+
+	/// \brief Return the field's name
+	const char* name() const { return name_.c_str(); }
+
+#if defined(NO_DEFAULT_VALUE_FLAG)
+	/// \brief Returns true if field has no default value
+	bool no_default() const { return flags_ & NO_DEFAULT_VALUE_FLAG; }
+#endif
+
+	/// \brief Returns true if field is part of a primary key
+	bool primary_key() const { return flags_ & PRI_KEY_FLAG; }
+
+	/// \brief Returns true if field is of some 'set' type
+	bool set_type() const { return flags_ & SET_FLAG; }
+
+	/// \brief Return the name of the table the field comes from
+	const char* table() const { return table_.c_str(); }
+
+	/// \brief Returns true if field's type is timestamp
+	bool timestamp() const { return flags_ & TIMESTAMP_FLAG; }
+
+	/// \brief Return information about the field's type
+	const mysql_type_info& type() const { return type_; }
+
+	/// \brief Returns true if field is part of a unique key
+	bool unique_key() const { return flags_ & UNIQUE_KEY_FLAG; }
+
+	/// \brief Returns true if field has the zerofill attribute
+	bool zerofill() const { return flags_ & ZEROFILL_FLAG; }
+
+private:
+	std::string name_;		///< the field's name
+	std::string table_;		///< name of table field comes from
+	std::string db_;		///< name of database field comes from
+	mysql_type_info type_;	///< info about the field's type
+	size_t length_;			///< creation size of column
+	size_t max_length_;		///< size of largest item in column in result set
+	unsigned int flags_;	///< DB engine-specific set of bit flags
+};
+
+
+/// \brief The list-of-Fields type
+typedef std::vector<Field> Fields;
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_FIELD_H)

ADDED   lib/field_names.cpp
Index: lib/field_names.cpp
==================================================================
--- /dev/null
+++ lib/field_names.cpp
@@ -0,0 +1,59 @@
+/***********************************************************************
+ field_names.cpp - Implements the FieldNames class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "common.h"
+
+#include "field_names.h"
+#include "result.h"
+
+#include <algorithm>
+
+namespace mysqlpp {
+
+void 
+FieldNames::init(const ResultBase* res)
+{
+	int num = res->num_fields();
+	reserve(num);
+
+	for (int i = 0; i < num; i++) {
+		std::string p(res->fields().at(i).name());
+		str_to_lwr(p);
+		push_back(p);
+	}
+}
+
+
+unsigned int
+FieldNames::operator [](const std::string& s) const
+{
+	std::string temp(s);
+	str_to_lwr(temp);
+	return static_cast<unsigned int>(std::find(begin(), end(), temp) - begin());
+}
+
+} // end namespace mysqlpp

ADDED   lib/field_names.h
Index: lib/field_names.h
==================================================================
--- /dev/null
+++ lib/field_names.h
@@ -0,0 +1,114 @@
+/// \file field_names.h
+/// \brief Declares a class to hold a list of field names.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#ifndef MYSQLPP_FIELD_NAMES_H
+#define MYSQLPP_FIELD_NAMES_H
+
+#include <string>
+#include <vector>
+
+#include <ctype.h>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class MYSQLPP_EXPORT ResultBase;
+#endif
+
+/// \brief Holds a list of SQL field names
+class FieldNames : public std::vector<std::string>
+{
+public:
+	/// \brief Default constructor
+	FieldNames() { }
+
+	/// \brief Copy constructor
+	FieldNames(const FieldNames& other) :
+	std::vector<std::string>()
+	{
+		assign(other.begin(), other.end());
+	}
+	
+	/// \brief Create field name list from a result set
+	FieldNames(const ResultBase* res) :
+	std::vector<std::string>()
+	{
+		init(res);
+	}
+
+	/// \brief Create empty field name list, reserving space for
+	/// a fixed number of field names.
+	FieldNames(int i) :
+	std::vector<std::string>(i)
+	{
+	}
+
+	/// \brief Initializes the field list from a result set
+	FieldNames& operator =(const ResultBase* res)
+	{
+		init(res);
+		return *this;
+	}
+
+	/// \brief Insert \c i empty field names at beginning of list
+	FieldNames& operator =(int i)
+	{
+		insert(begin(), i, "");
+		return *this;
+	}
+
+	/// \brief Get the name of a field given its index.
+	std::string& operator [](int i)
+	{
+		return at(i);
+	}
+
+	/// \brief Get the name of a field given its index, in const
+	/// context.
+	const std::string& operator [](int i) const
+	{
+		return at(i);
+	}
+
+	/// \brief Get the index number of a field given its name
+	unsigned int operator [](const std::string& s) const;
+
+private:
+	void init(const ResultBase* res);
+	void str_to_lwr(std::string& s) const
+	{
+		std::string::iterator it;
+		for (it = s.begin(); it != s.end(); ++it) {
+			*it = tolower(*it);
+		}
+	}
+};
+
+} // end namespace mysqlpp
+
+#endif

ADDED   lib/field_types.cpp
Index: lib/field_types.cpp
==================================================================
--- /dev/null
+++ lib/field_types.cpp
@@ -0,0 +1,45 @@
+/***********************************************************************
+ field_types.cpp - Implements the FieldTypes class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "common.h"
+
+#include "field_types.h"
+
+#include "result.h"
+
+namespace mysqlpp {
+
+void FieldTypes::init(const ResultBase* res)
+{
+	int num = res->num_fields();
+	reserve(num);
+	for (int i = 0; i < num; i++) {
+		push_back(res->field(i).type());
+	}
+}
+
+} // end namespace mysqlpp

ADDED   lib/field_types.h
Index: lib/field_types.h
==================================================================
--- /dev/null
+++ lib/field_types.h
@@ -0,0 +1,84 @@
+/// \file field_types.h
+/// \brief Declares a class to hold a list of SQL field type info.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
+ MySQL AB, and (c) 2004-2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#ifndef MYSQLPP_FIELD_TYPES_H
+#define MYSQLPP_FIELD_TYPES_H
+
+#include "type_info.h"
+
+#include <vector>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class MYSQLPP_EXPORT ResultBase;
+#endif
+
+/// \brief A vector of SQL field types.
+class FieldTypes : public std::vector<mysql_type_info>
+{
+public:
+	/// \brief Default constructor
+	FieldTypes() { }
+	
+	/// \brief Create list of field types from a result set
+	FieldTypes(const ResultBase* res)
+	{
+		init(res);
+	}
+
+	/// \brief Create fixed-size list of uninitialized field types
+	FieldTypes(int i) :
+	std::vector<mysql_type_info>(i)
+	{
+	}
+
+	/// \brief Initialize field list based on a result set
+	FieldTypes& operator =(const ResultBase* res)
+	{
+		init(res);
+		return *this;
+	}
+
+	/// \brief Insert a given number of uninitialized field type
+	/// objects at the beginning of the list
+	///
+	/// \param i number of field type objects to insert
+	FieldTypes& operator =(int i)
+	{
+		insert(begin(), i, mysql_type_info());
+		return *this;
+	}
+
+private:
+	void init(const ResultBase* res);
+};
+
+} // end namespace mysqlpp
+
+#endif

ADDED   lib/manip.cpp
Index: lib/manip.cpp
==================================================================
--- /dev/null
+++ lib/manip.cpp
@@ -0,0 +1,253 @@
+/***********************************************************************
+ manip.cpp - Implements MySQL++'s various quoting/escaping stream
+	manipulators.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "manip.h"
+
+#include "query.h"
+
+using namespace std;
+
+namespace mysqlpp {
+
+SQLQueryParms&
+operator <<(quote_type2 p, SQLTypeAdapter& in)
+{
+	if (in.quote_q()) {
+		string temp("'", 1), escaped;
+		p.qparms->escape_string(&escaped, in.data(), in.length());
+		temp.append(escaped);
+		temp.append("'", 1);
+		*p.qparms << SQLTypeAdapter(temp, true);
+		return *p.qparms;
+	}
+	else {
+		in.set_processed();
+		return *p.qparms << in;
+	}
+}
+
+
+ostream&
+operator <<(quote_type1 o, const SQLTypeAdapter& in)
+{
+	Query* pq = dynamic_cast<Query*>(o.ostr);
+
+	if (pq && in.quote_q()) o.ostr->put('\'');
+
+	if (pq) {
+		// It's a Query stream, so we'll be using unformatted output.
+		// Now, is escaping appropriate for source data type of 'in'?
+		if (in.escape_q()) {
+			string escaped;
+			pq->escape_string(&escaped, in.data(), in.length());
+			o.ostr->write(escaped.data(), escaped.length());
+		}
+		else {
+			o.ostr->write(in.data(), in.length());
+		}
+	}
+	else {
+		// Some other stream type, so use formatted output.  User
+		// shouldn't be trying to use the quote manipulator, but
+		// that's no reason to break their formatting.
+		*o.ostr << string(in.data(), in.length());
+	}
+
+	if (pq && in.quote_q()) o.ostr->put('\'');
+
+	return *o.ostr;
+}
+
+
+ostream&
+operator <<(quote_only_type1 o, const SQLTypeAdapter& in)
+{
+	Query* pq = dynamic_cast<Query*>(o.ostr);
+
+	if (pq && in.quote_q()) o.ostr->put('\'');
+
+	if (pq) {
+		// It's a Query stream, so use unformatted output
+		o.ostr->write(in.data(), in.length());
+	}
+	else {
+		// Some other stream type, so use formatted output.  User
+		// shouldn't be trying to use this manipulator on a non-Query
+		// stream, but that's no reason to break their formatting.
+		*o.ostr << '\'' << in << '\'';
+	}
+
+	if (pq && in.quote_q()) o.ostr->put('\'');
+
+	return *o.ostr;
+}
+
+
+ostream&
+operator <<(ostream& o, const SQLTypeAdapter& in)
+{
+	if (dynamic_cast<Query*>(&o)) {
+		// It's a Query stream, so use unformatted output.
+		return o.write(in.data(), in.length());
+	}
+	else {
+		// Some other stream type, so use formatted output.  We do this
+		// through the temporary so we remain null-friendly.
+		return o << string(in.data(), in.length());
+	}
+}
+
+
+SQLQueryParms&
+operator <<(quote_only_type2 p, SQLTypeAdapter& in)
+{
+	if (in.quote_q()) {
+		string temp("'", 1);
+		temp.append(in.data(), in.length());
+		temp.append("'", 1);
+		return *p.qparms << SQLTypeAdapter(temp, true);
+	}
+	else {
+		in.set_processed();
+		return *p.qparms << in;
+	}
+}
+
+
+SQLQueryParms&
+operator <<(quote_double_only_type2 p, SQLTypeAdapter& in)
+{
+	if (in.quote_q()) {
+		string temp("\"", 1);
+		temp.append(in.data(), in.length());
+		temp.append("\"", 1);
+		return *p.qparms << SQLTypeAdapter(temp, true);
+	}
+	else {
+		in.set_processed();
+		return *p.qparms << in;
+	}
+}
+
+
+ostream&
+operator <<(quote_double_only_type1 o, const SQLTypeAdapter& in)
+{
+	Query* pq = dynamic_cast<Query*>(o.ostr);
+
+	if (pq && in.quote_q()) o.ostr->put('"');
+
+	if (pq) {
+		// It's a Query stream, so use unformatted output
+		o.ostr->write(in.data(), in.length());
+	}
+	else {
+		// Some other stream type, so use formatted output.  User
+		// shouldn't be trying to use this manipulator on a non-Query
+		// stream, but that's no reason to break their formatting.
+		*o.ostr << '"' << in << '"';
+	}
+
+	if (pq && in.quote_q()) o.ostr->put('"');
+
+	return *o.ostr;
+}
+
+
+SQLQueryParms&
+operator <<(escape_type2 p, SQLTypeAdapter& in)
+{
+	if (in.escape_q()) {
+		string escaped;
+		p.qparms->escape_string(&escaped, in.data(), in.length());
+		*p.qparms << SQLTypeAdapter(escaped, true);
+		return *p.qparms;
+	}
+	else {
+		in.set_processed();
+		return *p.qparms << in;
+	}
+}
+
+
+ostream&
+operator <<(escape_type1 o, const SQLTypeAdapter& in)
+{
+	Query* pq = dynamic_cast<Query*>(o.ostr);
+	if (pq) {
+		// It's a Query stream, so we'll be using unformatted output.
+		// Now, is escaping appropriate for source data type of 'in'?
+		if (in.escape_q()) {
+			string escaped;
+			pq->escape_string(&escaped, in.data(), in.length());
+			return o.ostr->write(escaped.data(), escaped.length());
+		}
+		else {
+			return o.ostr->write(in.data(), in.length());
+		}
+	}
+	else {
+		// Some other stream type, so use formatted output.  User
+		// shouldn't be trying to use the escape manipulator, but
+		// that's no reason to break their formatting.
+		return *o.ostr << string(in.data(), in.length());
+	}
+}
+
+
+SQLQueryParms&
+operator <<(do_nothing_type2 p, SQLTypeAdapter& in)
+{
+	in.set_processed();
+	return *p.qparms << in;
+}
+
+
+ostream&
+operator <<(do_nothing_type1 o, const SQLTypeAdapter& in)
+{
+	if (dynamic_cast<Query*>(o.ostr)) {
+		// It's a Query stream, so use unformatted output
+		return o.ostr->write(in.data(), in.length());
+	}
+	else {
+		// Some other stream type, so use formatted output.  User
+		// shouldn't be trying to use this manipulator on a non-Query
+		// stream, but that's no reason to break their formatting.
+		return *o.ostr << in;
+	}
+}
+
+
+SQLQueryParms&
+operator <<(ignore_type2 p, SQLTypeAdapter& in)
+{
+	return *p.qparms << in;
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/manip.h
Index: lib/manip.h
==================================================================
--- /dev/null
+++ lib/manip.h
@@ -0,0 +1,488 @@
+/// \file manip.h
+/// \brief Declares the Query stream manipulators and operators.
+///
+/// These manipulators let you automatically quote elements or escape
+/// characters that are special in SQL when inserting them into a
+/// Query stream.  They make it easier to build syntactically-correct
+/// SQL queries.
+///
+/// This file also includes special \c operator<< definitions for a few
+/// key MySQL++ data types, since we know when to do automatic quoting
+/// and escaping for these types.  This only works with Query streams,
+/// not regular std::ostreams, since we're only concerned with making
+/// correct SQL, not with presentation matters.
+///
+/// test/test_manip.cpp exercises the mechanisms defined here.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#ifndef MYSQLPP_MANIP_H
+#define MYSQLPP_MANIP_H
+
+#include "common.h"
+
+#include "myset.h"
+#include "stadapter.h"
+
+#include <iostream>
+
+namespace mysqlpp {
+
+class SQLQueryParms;
+
+
+/// \enum quote_type0
+/// \anchor quote_manip
+///
+/// The standard 'quote' manipulator.  It is the most widely useful
+/// manipulator in MySQL++.
+///
+/// Insert this manipulator into a Query or SQLQueryParms stream to put
+/// single quotes around the next item in the stream, and escape any
+/// characters within it that are special in SQL, if the data type of
+/// the next item in the stream may require it.  By contrast, Date
+/// objects only require escaping, not quoting, and integers never
+/// require either.  The manipulators won't do work they know is not
+/// necessary to ensure syntactially-correct SQL.
+
+enum quote_type0
+{
+	quote ///< insert into a Query stream to single-quote and escape next item
+};
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+struct quote_type1
+{
+	std::ostream * ostr;
+	quote_type1(std::ostream * o) :
+	ostr(o)
+	{
+	}
+};
+
+
+inline quote_type1
+operator <<(std::ostream& o, quote_type0 /* esc */)
+{
+	return quote_type1(&o);
+}
+
+
+struct quote_type2
+{
+	SQLQueryParms *qparms;
+	quote_type2(SQLQueryParms* p) :
+	qparms(p)
+	{
+	}
+};
+
+
+inline quote_type2
+operator <<(SQLQueryParms& p, quote_type0 /* esc */)
+{
+	return quote_type2(&p);
+}
+
+
+/// \brief Inserts a SQLTypeAdapter into a stream, quoted and escaped
+/// as appropriate to the data type the object was initialized from.
+
+MYSQLPP_EXPORT SQLQueryParms& operator <<(quote_type2 p,
+		SQLTypeAdapter& in);
+
+
+/// \brief Inserts a anything that can be converted to SQLTypeAdapter
+/// into a stream, quoted and escaped as needed if it's a Query stream
+
+MYSQLPP_EXPORT std::ostream& operator <<(quote_type1 o,
+		const SQLTypeAdapter& in);
+
+
+/// \brief Inserts a SQLTypeAdapter into a non-Query stream.
+///
+/// Although we know how to quote and escape SQLTypeAdapter objects, we
+/// only do that when inserting them into Query streams or when given an
+/// explicit manipulator because this feature is only intended to make
+/// it easier to build syntactically-correct SQL queries.
+
+MYSQLPP_EXPORT std::ostream& operator <<(std::ostream& o,
+		const SQLTypeAdapter& in);
+
+
+template <class ST>
+inline std::ostream& 
+operator <<(quote_type1 o, const Set<ST>& in)
+{
+	return *o.ostr << '\'' << in << '\'';
+}
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+/// \enum quote_only_type0
+/// \anchor quote_only_manip
+///
+/// The 'quote_only' manipulator.
+///
+/// Similar to <a href="#quote_manip">quote manipulator</a>, except that
+/// it doesn't escape special SQL characters.
+
+enum quote_only_type0
+{
+	quote_only				///< insert into a std::ostream to single-quote next item
+};
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+struct quote_only_type1
+{
+	std::ostream* ostr;
+	quote_only_type1(std::ostream* o) :
+	ostr(o)
+	{
+	}
+};
+
+
+inline quote_only_type1
+operator <<(std::ostream& o, quote_only_type0 /* esc */)
+{
+	return quote_only_type1(&o);
+}
+
+
+struct quote_only_type2
+{
+	SQLQueryParms* qparms;
+	quote_only_type2(SQLQueryParms* p) :
+	qparms(p)
+	{
+	}
+};
+
+
+inline quote_only_type2 
+operator <<(SQLQueryParms& p, quote_only_type0 /* esc */)
+{
+	return quote_only_type2(&p);
+}
+
+
+/// \brief Inserts a SQLTypeAdapter into a stream, quoting it unless it's
+/// data that needs no quoting.
+///
+/// We make the decision to quote the data based on the in.quote_q()
+/// flag.  You can set it yourself, but SQLTypeAdapter's ctors should set
+/// it correctly for you.
+
+MYSQLPP_EXPORT SQLQueryParms& operator <<(quote_only_type2 p,
+		SQLTypeAdapter& in);
+
+
+std::ostream& operator <<(quote_only_type1 o, const SQLTypeAdapter& in);
+
+
+template <class ST>
+inline std::ostream& 
+operator <<(quote_only_type1 o, const Set<ST>& in)
+{
+	return *o.ostr << '\'' << in << '\'';
+}
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+/// \enum quote_double_only_type0
+/// \anchor quote_double_manip
+///
+/// The 'double_quote_only' manipulator.
+///
+/// Similar to <a href="#quote_only_manip">quote_only manipulator</a>,
+/// except that it uses double quotes instead of single quotes.
+///
+/// You might care to use it when you have MySQL's \c ANSI_QUOTES mode
+/// enabled.  In that mode, single quotes are used only for string
+/// literals, and double quotes for identifiers.  Otherwise,
+/// \c quote_only and \c quote are quite sufficient.
+
+enum quote_double_only_type0
+{
+	quote_double_only ///< insert into a std::ostream to double-quote next item
+};
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+struct quote_double_only_type1
+{
+	std::ostream* ostr;
+	quote_double_only_type1(std::ostream* o) :
+	ostr(o)
+	{
+	}
+};
+
+
+inline quote_double_only_type1
+operator <<(std::ostream& o, quote_double_only_type0 /* esc */)
+{
+	return quote_double_only_type1(&o);
+}
+
+
+struct quote_double_only_type2
+{
+	SQLQueryParms *qparms;
+	quote_double_only_type2(SQLQueryParms* p) :
+	qparms(p)
+	{
+	}
+};
+
+
+inline quote_double_only_type2
+operator <<(SQLQueryParms& p, quote_double_only_type0 /* esc */)
+{
+	return quote_double_only_type2(&p);
+}
+
+
+/// \brief Inserts a SQLTypeAdapter into a stream, double-quoting it (")
+/// unless it's data that needs no quoting.
+///
+/// We make the decision to quote the data based on the in.quote_q()
+/// flag.  You can set it yourself, but SQLTypeAdapter's ctors should set
+/// it correctly for you.
+
+MYSQLPP_EXPORT SQLQueryParms&
+operator <<(quote_double_only_type2 p, SQLTypeAdapter& in);
+
+
+std::ostream&
+operator <<(quote_double_only_type1 o, const SQLTypeAdapter& in);
+
+
+template <class ST>
+inline std::ostream&
+operator <<(quote_double_only_type1 o, const Set<ST>& in)
+{
+	return *o.ostr << '"' << in << '"';
+}
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+/// \enum escape_type0
+/// The 'escape' manipulator.
+///
+/// SQL-escapes following argument if it is of a data type that
+/// may require escaping when inserted into a Query or SQLQueryParms
+/// stream.  This is useful with string types, for example, to avoid
+/// bad SQL when they contain special characters like single quotes,
+/// nulls, and newlines.  Data types like integers which never benefit
+/// from escaping don't get run through the escaping routine even if
+/// you ask for it.
+
+enum escape_type0 { escape };
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+struct escape_type1
+{
+	std::ostream* ostr;
+	escape_type1(std::ostream* o) :
+	ostr(o)
+	{
+	}
+};
+
+
+inline escape_type1
+operator <<(std::ostream& o, escape_type0 /* esc */)
+{
+	return escape_type1(&o);
+}
+
+
+struct escape_type2
+{
+	SQLQueryParms *qparms;
+	escape_type2(SQLQueryParms* p) :
+	qparms(p)
+	{
+	}
+};
+
+
+inline escape_type2
+operator <<(SQLQueryParms& p, escape_type0 /* esc */)
+{
+	return escape_type2(&p);
+}
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+/// \brief Inserts a SQLTypeAdapter into a stream, escaping special SQL
+/// characters
+///
+/// We actually only do the escaping if in.escape_q() returns true but
+/// in.dont_escape is not.  If that is not the case, we insert the
+/// string data directly.
+
+MYSQLPP_EXPORT SQLQueryParms& operator <<(escape_type2 p,
+		SQLTypeAdapter& in);
+
+
+/// \brief Inserts anything that can be converted to SQLTypeAdapter into
+/// a stream, escaping special SQL characters as needed.
+
+MYSQLPP_EXPORT std::ostream& operator <<(escape_type1 o,
+		const SQLTypeAdapter& in);
+
+
+/// \enum do_nothing_type0
+/// \anchor do_nothing_manip
+///
+/// The 'do_nothing' manipulator.
+///
+/// Does exactly what it says: nothing. Used as a dummy manipulator when
+/// you are required to use some manipulator but don't want anything to
+/// be done to the following item. When used with SQLQueryParms it will
+/// make sure that it does not get formatted in any way, overriding any
+/// setting set by the template query.
+
+enum do_nothing_type0
+{
+	do_nothing				///< insert into a std::ostream to override manipulation of next item
+};
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+struct do_nothing_type1
+{
+	std::ostream* ostr;
+	do_nothing_type1(std::ostream* o) :
+	ostr(o)
+	{
+	}
+};
+
+
+inline do_nothing_type1
+operator <<(std::ostream& o, do_nothing_type0 /* esc */)
+{
+	return do_nothing_type1(&o);
+}
+
+
+MYSQLPP_EXPORT std::ostream&
+operator <<(do_nothing_type1 o, const SQLTypeAdapter& in);
+
+
+struct do_nothing_type2
+{
+	SQLQueryParms *qparms;
+	do_nothing_type2(SQLQueryParms* p) :
+	qparms(p)
+	{
+	}
+};
+
+
+inline do_nothing_type2
+operator <<(SQLQueryParms& p, do_nothing_type0 /* esc */)
+{
+	return do_nothing_type2(&p);
+}
+
+
+/// \brief Inserts a SQLTypeAdapter into a stream, with no escaping or
+/// quoting.
+
+MYSQLPP_EXPORT SQLQueryParms& operator <<(do_nothing_type2 p,
+		SQLTypeAdapter& in);
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+/// \enum ignore_type0
+/// \anchor ignore_manip
+///
+/// The 'ignore' manipulator.
+///
+/// Only valid when used with SQLQueryParms. It's a dummy manipulator
+/// like the <a href="#do_nothing_manip">do_nothing manipulator</a>,
+/// except that it will not override formatting set by the template
+/// query.  It is simply ignored.
+
+enum ignore_type0
+{
+	ignore					///< insert into a std::ostream as a dummy manipulator
+};
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+struct ignore_type2
+{
+	SQLQueryParms* qparms;
+	ignore_type2(SQLQueryParms* p) :
+	qparms(p)
+	{
+	}
+};
+
+
+inline ignore_type2
+operator <<(SQLQueryParms& p, ignore_type0 /* esc */)
+{
+	return ignore_type2(&p);
+}
+
+
+/// \brief Inserts a SQLTypeAdapter into a stream, with no escaping or
+/// quoting, and without marking the string as having been "processed".
+
+MYSQLPP_EXPORT SQLQueryParms& operator <<(ignore_type2 p,
+		SQLTypeAdapter& in);
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+} // end namespace mysqlpp
+
+#endif

ADDED   lib/myset.cpp
Index: lib/myset.cpp
==================================================================
--- /dev/null
+++ lib/myset.cpp
@@ -0,0 +1,35 @@
+/***********************************************************************
+ myset.cpp - Implements the Set template.  (Not to be confused with
+	std::set, which this template wraps.)
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
+ MySQL AB, and (c) 2004, 2005 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "myset.h"
+
+namespace mysqlpp {
+
+template class Set<std::set<std::string> >;
+
+} // end namespace mysqlpp
+

ADDED   lib/myset.h
Index: lib/myset.h
==================================================================
--- /dev/null
+++ lib/myset.h
@@ -0,0 +1,161 @@
+/// \file myset.h
+/// \brief Declares templates for generating custom containers used
+/// elsewhere in the library.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#ifndef MYSQLPP_MYSET_H
+#define MYSQLPP_MYSET_H
+
+#include "common.h"
+
+#include "mystring.h"
+#include "stream2string.h"
+
+#include <iostream>
+#include <set>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+template <class T, class key_type = typename T::key_type>
+class MYSQLPP_EXPORT SetInsert
+{
+public:
+	SetInsert(T* o) : object_(o) { }
+	void operator ()(const key_type& data) { object_->insert(data); }
+
+private:
+	T* object_;
+};
+
+template <class T>
+inline SetInsert< std::set<T> > set_insert(std::set<T>* o)
+{
+	return SetInsert< std::set<T> >(o);
+}
+
+template <class Insert>
+void set2container(const char* str, Insert insert);
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+/// \brief A special std::set derivative for holding MySQL data sets.
+
+template <class Container = std::set<std::string> >
+class MYSQLPP_EXPORT Set : public Container
+{
+public:
+	/// \brief Default constructor
+	Set() {};
+
+	/// \brief Create object from a comma-separated list of values
+	Set(const char* str)
+	{
+		set2container(str, set_insert(this));
+	}
+	
+	/// \brief Create object from a comma-separated list of values
+	Set(const std::string& str)
+	{
+		set2container(str.c_str(), set_insert(this));
+	}
+	
+	/// \brief Create object from a comma-separated list of values
+	Set(const String& str)
+	{
+		set2container(str.c_str(), set_insert(this));
+	}
+
+	/// \brief Convert this set's data to a string containing
+	/// comma-separated items.
+	operator std::string() const { return stream2string(*this); }
+
+	/// \brief Return our value in std::string form
+	std::string str() const { return *this; }
+};
+
+
+/// \brief Inserts a Set object into a C++ stream
+template <class Container>
+inline std::ostream& operator <<(std::ostream& s,
+		const Set<Container>& d)
+{
+	typename Container::const_iterator i = d.begin();
+	typename Container::const_iterator e = d.end();
+
+	if (i != e) {
+		while (true) {
+			s << *i;
+			if (++i == e) {
+				break;
+			}
+			s << ",";
+		}
+	}
+	
+	return s;
+}
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+template <class Insert>
+void set2container(const char* str, Insert insert)
+{
+	std::string temp;
+
+	// Break str up using comma separators
+	while (str && *str) {
+		if (*str == ',') {
+			insert(temp);
+			temp.clear();
+
+			// Handle comma at end of string case
+			if (*++str) {
+				++str;
+			}
+		}
+		else {
+			temp += *str++;
+		}
+	}
+
+	// Save final element of set, if any
+	if (temp.size()) {
+		insert(temp);
+	}
+}
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+} // end namespace mysqlpp
+
+#endif

ADDED   lib/mysql++.cpp
Index: lib/mysql++.cpp
==================================================================
--- /dev/null
+++ lib/mysql++.cpp
@@ -0,0 +1,38 @@
+/***********************************************************************
+ mysql++.cpp - Implements functions dealing with the library itself,
+	as opposed to individual features of the library.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "mysql++.h"
+
+namespace mysqlpp {
+
+unsigned int 
+get_library_version()
+{
+	return MYSQLPP_HEADER_VERSION;
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/mysql++.h.in
Index: lib/mysql++.h.in
==================================================================
--- /dev/null
+++ lib/mysql++.h.in
@@ -0,0 +1,156 @@
+/// \file mysql++.h
+/// \brief The main MySQL++ header file.
+///
+/// This file brings in all MySQL++ headers except for custom.h and
+/// custom-macros.h which are a strictly optional feature of MySQL++.
+///
+/// There is no point in trying to optimize which headers you include,
+/// because the MySQL++ headers are so intertwined.  You can only get
+/// trivial compile time benefits, at the expense of clarity.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#ifndef MYSQLPP_MYSQLPP_H
+#define MYSQLPP_MYSQLPP_H
+
+/// \brief Encode MySQL++ library version number.
+///
+/// This macro takes major, minor and bugfix numbers (e.g. 1, 2, and 3)
+/// and encodes them like 0x010203.
+#define MYSQLPP_VERSION(major, minor, bugfix) \
+		(((major) << 16) | ((minor) << 8) | (bugfix))
+
+/// \brief Get the library version number that mysql++.h comes from
+///
+/// MySQL++ Version number that the mysql++.h header file comes from,
+/// encoded by MYSQLPP_VERSION macro.  Compare this value to what
+/// mysqlpp_lib_version() returns in order to ensure that your program
+/// is using header files from the same version of MySQL++ as the
+/// actual library you're linking to.
+#define MYSQLPP_HEADER_VERSION MYSQLPP_VERSION(@MYSQLPP_VERSION_MAJOR@, @MYSQLPP_VERSION_MINOR@, @MYSQLPP_VERSION_BUGFIX@)
+
+// This #include order gives the fewest redundancies in the #include
+// dependency chain.
+#include "connection.h"
+#include "cpool.h"
+#include "query.h"
+#include "sql_types.h"
+#include "transaction.h"
+
+namespace mysqlpp {
+
+/// \brief Get the current MySQL++ library version number
+///
+/// MySQL++ version number that the program is actually linked to,
+/// encoded by MYSQLPP_VERSION macro.  Compare this value to the
+/// MYSQLPP_HEADER_VERSION constant in order to ensure that your
+/// program is using header files from the same version of MySQL++ as
+/// the actual library you're linking to.
+MYSQLPP_EXPORT unsigned int get_library_version();
+
+// This won't exist forever!  Wean yourself away from these as soon as
+// you can!
+#if defined(MYSQLPP_OLD_CLASS_NAMES)
+#	define ColData String
+#	define NullisBlank NullIsBlank
+#	define NullisNull NullIsNull
+#	define NullisZero NullIsZero
+#	define ResNSel SimpleResult
+#	define Result StoreQueryResult
+#	define ResUse UseQueryResult
+#	define SQLString SQLTypeAdapter
+#endif
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_MYSQLPP_H)
+
+
+/**
+	\mainpage MySQL++ Reference Manual
+
+	\section getting_started Getting Started
+
+	The best place to get started is the
+	<a href="../userman/index.html">user manual</a>. It provides
+	a guide to the example programs and more.
+
+
+	\section classes Major Classes
+
+	In MySQL++, the main user-facing classes are
+	mysqlpp::Connection, mysqlpp::Query, mysqlpp::Row,
+	mysqlpp::StoreQueryResult, and mysqlpp::UseQueryResult.
+
+	In addition, MySQL++ has a mechanism called Specialized SQL
+	Structures (SSQLS), which allow you to create C++ structures
+	that parallel the definition of the tables in your database
+	schema. These let you manipulate the data in your database using
+	native C++ data structures. Programs using this feature often
+	include very little SQL code, because MySQL++ can generate most
+	of what you need automatically when using SSQLSes. There is a
+	whole chapter in the user manual on how to use this feature of
+	the library, plus a section in the user manual's tutorial chapter
+	to introduce it. It's possible to use MySQL++ effectively without
+	using SSQLS, but it sure makes some things a lot easier.
+
+
+	\section files Major Files
+
+	The only two header files your program ever needs to include
+	are mysql++.h, and optionally custom.h. (The latter implements
+	the SSQLS mechanism.) All of the other files are used within
+	the library only.
+
+
+	\section user_questions If You Have Questions...
+
+	If you want to email someone to ask questions about this library,
+	we greatly prefer that you send mail to the MySQL++ mailing list,
+	which you can subscribe to here: http://lists.mysql.com/plusplus
+
+	That mailing list is archived, so if you have questions, do a
+	search to see if the question has been asked before.
+
+	You may find people's individual email addresses in various
+	files within the MySQL++ distribution. Please do not send mail
+	to them unless you are sending something that is inherently
+	personal. Questions that are about MySQL++ usage may well be
+	ignored if you send them to our personal email accounts. Those of
+	us still active in MySQL++ development monitor the mailing list,
+	so you aren't getting any extra "coverage" by sending messages
+	to those addresses in addition to the mailing list.
+
+
+	\section licensing Licensing
+
+	MySQL++ is licensed under the GNU Lesser General Public License,
+	which you should have received with the distribution package in
+	a file called "LGPL" or "LICENSE". You can also view it here:
+	http://www.gnu.org/licenses/lgpl.html or receive a copy by
+	writing to Free Software Foundation, Inc., 51 Franklin Street,
+	Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+

ADDED   lib/mystring.cpp
Index: lib/mystring.cpp
==================================================================
--- /dev/null
+++ lib/mystring.cpp
@@ -0,0 +1,263 @@
+/***********************************************************************
+ mystring.cpp - Implements the String class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "mystring.h"
+#include "query.h"
+
+#include <algorithm>
+#include <stdexcept>
+#include <string>
+
+namespace mysqlpp {
+
+
+char
+String::at(size_type pos) const
+{
+	if (pos >= size()) {
+		throw std::out_of_range("String");
+	}
+	else {
+		return buffer_->data()[pos];
+	}
+}
+
+
+int
+String::compare(const String& other) const
+{
+	if (other.buffer_) {
+		return compare(0, std::max(length(), other.length()), 
+				other.buffer_->data());
+	}
+	else {
+		// Other object has no buffer, so we are greater unless empty or
+		// we also have no buffer.
+		return length() > 0 ? 1 : 0;	
+	}
+}
+
+
+int
+String::compare(const std::string& other) const
+{
+	return compare(0, std::max(length(), other.length()), other.data());
+}
+
+
+int
+String::compare(size_type pos, size_type num, std::string& other) const
+{
+	return compare(pos, num, other.data());
+}
+
+
+int
+String::compare(const char* other) const
+{
+	return compare(0, std::max(length(), strlen(other)), other);
+}
+
+
+int
+String::compare(size_type pos, size_type num,
+		const char* other) const
+{
+	if (buffer_ && other) {
+		return strncmp(data() + pos, other, num);
+	}
+	else if (!other) {
+		// Initted and non-empty is "greater than" uninitted
+		return length() > 0 ? 1 : 0;
+	}
+	else {
+		// This object has no buffer, so we are less than other object
+		// unless it is empty.
+		return other[0] == '\0' ? 0 : -1;
+	}
+}
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen isn't smart enough to recognize these template
+// specializations.  Maybe it's the MYSQLPP_EXPORT tags?
+
+template <>
+String
+String::conv(String) const { return *this; }
+
+
+template <>
+bool
+String::conv(bool) const
+{
+	return *this;	// delegate to operator bool
+}
+
+
+template <>
+std::string
+String::conv(std::string) const
+{
+	return buffer_ ? std::string(data(), length()) : std::string();
+}
+
+
+template <>
+Date
+String::conv(Date) const
+{
+	return buffer_ ? Date(c_str()) : Date();
+}
+
+
+template <>
+DateTime
+String::conv(DateTime) const
+{
+	return buffer_ ? DateTime(c_str()) : DateTime();
+}
+
+
+template <>
+Time
+String::conv(Time) const
+{
+	return buffer_ ? Time(c_str()) : Time(); 
+}
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+const char*
+String::data() const
+{
+	return buffer_ ? buffer_->data() : 0;
+}
+
+
+String::const_iterator
+String::end() const
+{
+	return buffer_ ? buffer_->data() + buffer_->length() : 0;
+}
+
+
+bool
+String::escape_q() const
+{
+	return buffer_ ? buffer_->type().escape_q() : false;
+}
+
+
+bool
+String::is_null() const
+{
+	return buffer_ ? buffer_->is_null() : false;
+}
+
+
+void
+String::it_is_null()
+{
+	if (buffer_) {
+		buffer_->set_null();
+	}
+	else {
+		buffer_ = new SQLBuffer(0, 0, mysql_type_info::string_type, true);
+	}
+}
+
+
+String::size_type
+String::length() const
+{
+	return buffer_ ? buffer_->length() : 0;
+}
+
+
+bool
+String::quote_q() const
+{
+	// If no buffer, it means we're an empty string, so we need to be 
+	// quoted to be expressed properly in SQL.
+	return buffer_ ? buffer_->type().quote_q() : true;
+}
+
+
+void
+String::to_string(std::string& s) const
+{
+	if (buffer_) {
+		s.assign(buffer_->data(), buffer_->length());
+	}
+	else {
+		s.clear();
+	}
+}
+
+
+char
+String::operator [](size_type pos) const
+{
+	return buffer_ ? buffer_->data()[pos] : 0;
+}
+
+/// \brief Stream insertion operator for String objects
+///
+/// This doesn't have anything to do with the automatic quoting and
+/// escaping you get when using SQLTypeAdapter with Query.  The need to
+/// use String with Query should be rare, since String generally comes
+/// in result sets; it should only go back out as queries when using
+/// result data in a new query.  Since SQLTypeAdapter has a conversion
+/// ctor for String, this shouldn't be a problem.  It's just trading
+/// simplicity for a tiny bit of inefficiency in a rare case.  And 
+/// since String and SQLTypeAdapter can share a buffer, it's not all
+/// that inefficient anyway.
+
+std::ostream&
+operator <<(std::ostream& o, const String& in)
+{
+	if (dynamic_cast<Query*>(&o)) {
+		// We can just insert the raw data into the stream
+		o.write(in.data(), in.length());
+	}
+	else {
+		// Can't guess what sort of stream it is, so convert the String
+		// to a std::string so we can use the formatted output method.
+		// To see why this is necessary, change it to use write() only
+		// (unformatted output) and then run simple2: notice that the
+		// columnar output formatting is wrecked.
+		std::string temp;
+		in.to_string(temp);
+		o << temp;
+	}
+	return o;
+}
+
+
+
+} // end namespace mysqlpp

ADDED   lib/mystring.h
Index: lib/mystring.h
==================================================================
--- /dev/null
+++ lib/mystring.h
@@ -0,0 +1,755 @@
+/// \file mystring.h
+/// \brief Declares String class, MySQL++'s generic std::string-like
+/// class, used for holding data received from the database server.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_MYSTRING_H)
+#define MYSQLPP_MYSTRING_H
+
+#include "common.h"
+
+#include "datetime.h"
+#include "exceptions.h"
+#include "null.h"
+#include "sql_buffer.h"
+
+#include <string>
+#include <sstream>
+#include <limits>
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+namespace detail
+{
+	template<typename T, bool is_signed = std::numeric_limits<T>::is_signed>
+	struct conv_promotion;
+
+	template<>
+	struct conv_promotion<float>
+	{
+		typedef double type;
+	};
+
+	template<>
+	struct conv_promotion<double>
+	{
+		typedef double type;
+	};
+
+#	if !defined(NO_LONG_LONGS)
+	template<>
+	struct conv_promotion<unsigned long long>
+	{
+		typedef unsigned long long type;
+	};
+
+	template<>
+	struct conv_promotion<long long>
+	{
+		typedef long long type;
+	};
+#	endif
+
+	// preserve existing behaviour, char converted as signed long
+	template<>
+	struct conv_promotion<char>
+	{
+		typedef long type;
+	};
+
+	// all other types use signed/unsigned long
+
+	template<typename T>
+	struct conv_promotion<T, true>
+	{
+		typedef long type;
+	};
+
+	template<typename T>
+	struct conv_promotion<T, false>
+	{
+		typedef unsigned long type;
+	};
+} // namespace detail
+
+class MYSQLPP_EXPORT SQLTypeAdapter;
+#endif // !defined(DOXYGEN_IGNORE)
+
+/// \brief A std::string work-alike that can convert itself from SQL
+/// text data formats to C++ data types.
+///
+/// This class is an intermediate form for a SQL field, normally
+/// converted to a more useful native C++ type, not used directly.
+/// The only exception is in dealing with BLOB data, which stays in
+/// String form for efficiency and to avoid corrupting the data with
+/// facile conversions.  Even then, it's best to use it through the 
+/// typedef aliases like sql_blob in sql_types.h, in case we later
+/// change this underlying representation.
+///
+/// String's implicit conversion operators let you can use these
+/// objects naturally:
+///
+/// \code String("12.86") + 2.0 \endcode
+///
+/// That will give you 14.86 (approximately) as you expect, but be
+/// careful not to get tripped up by C++'s type conversion rules.  If
+/// you had said this instead:
+/// 
+/// \code String("12.86") + 2 \endcode
+/// 
+/// the result would be 14 because 2 is an integer, and C++'s type
+/// conversion rules put the String object in an integer context.
+///
+/// You can disable the operator overloads that allow these things by
+/// defining MYSQLPP_NO_BINARY_OPERS.
+///
+/// This class also has some basic information about the type of data
+/// stored in it, to allow it to do the conversions more intelligently
+/// than a trivial implementation would allow.
+
+class MYSQLPP_EXPORT String
+{
+public:
+	/// \brief Type of the data stored in this object, when it is not
+	/// equal to SQL null.
+	typedef const char value_type;
+
+	/// \brief Type of "size" integers
+	typedef unsigned int size_type;
+
+	/// \brief Type of iterators
+	typedef const char* const_iterator;
+
+	/// \brief Same as const_iterator because the data cannot be
+	/// changed.
+	typedef const_iterator iterator;
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+	typedef int difference_type;
+	typedef const char* const_pointer;
+	typedef const_pointer pointer;
+#endif // !defined(DOXYGEN_IGNORE)
+
+	/// \brief Default constructor
+	///
+	/// An object constructed this way is essentially useless, but
+	/// sometimes you just need to construct a default object.
+	String() :
+	buffer_()
+	{
+	}
+
+	/// \brief Copy ctor
+	///
+	/// \param other the other String object
+	///
+	/// This ctor only copies the pointer to the other String's data
+	/// buffer and increments its reference counter.  If you need a
+	/// deep copy, use one of the ctors that takes a string.
+	String(const String& other) :
+	buffer_(other.buffer_)
+	{
+	}
+
+	/// \brief Full constructor.
+	///
+	/// \param str the string this object represents, or 0 for SQL null
+	/// \param len the length of the string; embedded nulls are legal
+	/// \param type MySQL type information for data within str
+	/// \param is_null string represents a SQL null, not literal data
+	///
+	/// The resulting object will contain a copy of the string buffer.
+	/// The buffer will actually be 1 byte longer than the value given
+	/// for \c len, to hold a null terminator for safety.  We do this
+	/// because this ctor may be used for things other than
+	/// null-terminated C strings.  (e.g. BLOB data)
+	explicit String(const char* str, size_type len,
+			mysql_type_info type = mysql_type_info::string_type,
+			bool is_null = false) :
+	buffer_(new SQLBuffer(str, len, type, is_null))
+	{
+	}
+
+	/// \brief C++ string version of full ctor
+	///
+	/// \param str the string this object represents, or 0 for SQL null
+	/// \param type MySQL type information for data within str
+	/// \param is_null string represents a SQL null, not literal data
+	///
+	/// The resulting object will contain a copy of the string buffer.
+	explicit String(const std::string& str,
+			mysql_type_info type = mysql_type_info::string_type,
+			bool is_null = false) :
+	buffer_(new SQLBuffer(str.data(), static_cast<size_type>(str.length()),
+			type, is_null))
+	{
+	}
+
+	/// \brief Null-terminated C string version of full ctor
+	///
+	/// \param str the string this object represents, or 0 for SQL null
+	/// \param type MySQL type information for data within str
+	/// \param is_null string represents a SQL null, not literal data
+	///
+	/// The resulting object will contain a copy of the string buffer.
+	explicit String(const char* str,
+			mysql_type_info type = mysql_type_info::string_type,
+			bool is_null = false) :
+	buffer_(new SQLBuffer(str, static_cast<size_type>(strlen(str)),
+			type, is_null))
+	{
+	}
+
+	/// \brief Destroy string
+	~String() { }
+
+	/// \brief Assign raw data to this object
+	///
+	/// This parallels the ctor with the same parameters, for when you
+	/// must do a 2-step create, or when you want to reassign the data 
+	/// without creating a String temporary to get around the fact
+	/// that operator=() can only take one parameter.
+	void assign(const char* str, size_type len,
+			mysql_type_info type = mysql_type_info::string_type,
+			bool is_null = false)
+	{
+		buffer_ = new SQLBuffer(str, len, type, is_null);
+	}
+
+	/// \brief Assign a C++ string to this object
+	///
+	/// This parallels the ctor with the same parameters, for when you
+	/// must do a 2-step create, or when you want to reassign the data 
+	/// without creating a String temporary to get around the fact
+	/// that operator=() can only take one parameter.
+	void assign(const std::string& str,
+			mysql_type_info type = mysql_type_info::string_type,
+			bool is_null = false)
+	{
+		buffer_ = new SQLBuffer(str.data(), 
+				static_cast<size_type>(str.length()), type, is_null);
+	}
+
+	/// \brief Assign a C string to this object
+	///
+	/// This parallels the ctor with the same parameters, for when you
+	/// must do a 2-step create, or when you want to reassign the data 
+	/// without creating a String temporary to get around the fact
+	/// that operator=() can only take one parameter.
+	void assign(const char* str,
+			mysql_type_info type = mysql_type_info::string_type,
+			bool is_null = false)
+	{
+		buffer_ = new SQLBuffer(str, static_cast<size_type>(strlen(str)),
+				type, is_null);
+	}
+
+	/// \brief Return a character within the string.
+	///
+	/// Unlike \c operator[](), this function throws an 
+	/// \c std::out_of_range exception if the index isn't within range.
+	char at(size_type pos) const;
+
+	/// \brief Return iterator pointing to the first character of
+	/// the string
+	const_iterator begin() const { return data(); }
+
+	/// \brief Return a const pointer to the string data.
+	const char* c_str() const { return data(); }
+	
+#if defined(MYSQLPP_PLATFORM_VISUAL_CPP)
+// Squish VC++ warning about "possible loss of data" for these conversions
+#   pragma warning(disable: 4244)
+#endif
+
+	/// \brief Template for converting the column data to most any
+	/// numeric data type.
+	template <class Type>
+	Type conv(Type) const
+	{
+		// Conversions are done using one of double/long/ulong/llong/ullong
+		// so we call a helper function to do the work using that type.
+		// This reduces the amount of template code instantiated.
+		typedef typename detail::conv_promotion<Type>::type conv_type;
+		return do_conv<conv_type>(typeid(Type).name());
+	}
+
+#if defined(MYSQLPP_PLATFORM_VISUAL_CPP)
+#   pragma warning(default: 4244)
+#endif
+
+	/// \brief Overload of conv() for types wrapped with Null<>
+	///
+	/// If the String object was initialized with some string we
+	/// recognize as a SQL null, we just return a copy of the global
+	/// 'null' object converted to the requested type.  Otherwise, we
+	/// return the String's value wrapped in the Null<> template.
+	template <class T, class B>
+	Null<T, B> conv(Null<T, B>) const
+	{
+		if (is_null()) {
+			return Null<T, B>(null);
+		}
+		else {
+			return Null<T, B>(conv(T()));
+		}
+	}
+
+	/// \brief Lexically compare this string to another.
+	///
+	/// \param other string to compare against this one
+	///
+	/// \see compare(size_type, size_type, const char*)
+	int compare(const String& other) const;
+
+	/// \brief Lexically compare this string to another.
+	///
+	/// \param other string to compare against this one
+	///
+	/// \see compare(size_type, size_type, const char*)
+	int compare(const std::string& other) const;
+
+	/// \brief Lexically compare this string to another.
+	///
+	/// \param pos position within this string to begin comparison
+	/// \param num maximum number of characters within this string to
+	/// use in comparison
+	/// \param other string to compare against this one
+	///
+	/// \see compare(size_type, size_type, const char*)
+	int compare(size_type pos, size_type num, std::string& other) const;
+
+	/// \brief Lexically compare this string to another.
+	///
+	/// \param other string to compare against this one
+	///
+	/// \see compare(size_type, size_type, const char*)
+	int compare(const char* other) const;
+
+	/// \brief Lexically compare this string to another.
+	///
+	/// \param pos position within this string to begin comparison
+	/// \param num maximum number of characters within this string to
+	/// use in comparison
+	/// \param other string to compare against this one
+	///
+	/// \retval < 0 if this string is lexically "less than" other
+	/// \retval 0 if this string is equal to other
+	/// \retval > 0 if this string is lexically "greater than" other
+	int compare(size_type pos, size_type num, const char* other) const;
+
+	/// \brief Raw access to the underlying buffer, with no C string
+	/// interpretation.
+	const char* data() const;
+	
+	/// \brief Return iterator pointing to one past the last character
+	/// of the string.
+	const_iterator end() const;
+
+	/// \brief Returns true if data of this type should be escaped, false
+	/// otherwise.
+	bool escape_q() const;
+
+	/// \brief Returns true if this object is a SQL null.
+	bool is_null() const;
+
+	/// \brief Set a flag indicating that this object is a SQL null.
+	void it_is_null();
+
+	/// \brief Return number of characters in the string
+	size_type length() const;
+	
+	/// \brief Return the maximum number of characters in the string.
+	///
+	/// Because this is a \c const string, this is just an alias for
+	/// size(); its size is always equal to the amount of data currently
+	/// stored.
+	size_type max_size() const { return size(); }
+
+	/// \brief Returns true if data of this type should be quoted, false
+	/// otherwise.
+	bool quote_q() const;
+
+	/// \brief Return number of characters in string
+	size_type size() const { return length(); }
+	
+    /// \brief Returns a copy of our internal string without leading
+    /// blanks.
+    void strip_leading_blanks(std::string& s) const
+    {
+        const char* pc = data();
+        if (pc) {
+            size_type n = length();
+            while (n && (*pc == ' ')) {
+                ++pc;
+                --n;
+            }
+
+            s.assign(pc, n);
+        }
+        else {
+            s.clear();
+        }
+    }
+
+	/// \brief Copies this object's data into a C++ string.
+	///
+	/// If you know the data doesn't contain null characters (i.e. it's
+	/// a typical string, not BLOB data), it's more efficient to just
+	/// assign this object to anything taking \c const \c char*.  (Or
+	/// equivalently, call the \c data() method.)  This copies a pointer
+	/// to a buffer instead of copying the buffer's contents.
+	void to_string(std::string& s) const;
+
+	/// \brief Get this object's current MySQL type.
+	mysql_type_info type() const
+	{
+		return buffer_ ? buffer_->type() : mysql_type_info::string_type;
+	}
+
+	/// \brief Assignment operator, from C++ string
+	String& operator =(const std::string& rhs)
+	{
+		buffer_ = new SQLBuffer(rhs.data(), 
+				static_cast<size_type>(rhs.length()),
+				mysql_type_info::string_type, false);
+
+		return *this;
+	}
+
+	/// \brief Assignment operator, from C string
+	///
+	/// This creates a copy of the entire string, not just a copy of
+	/// the pointer.
+	String& operator =(const char* str)
+	{
+		buffer_ = new SQLBuffer(str, 
+				static_cast<size_type>(strlen(str)),
+				mysql_type_info::string_type, false);
+
+		return *this;
+	}
+
+	/// \brief Assignment operator, from other String
+	///
+	/// This only copies the pointer to the other String's data
+	/// buffer and increments its reference counter.  If you need a
+	/// deep copy, assign a string to this object instead.
+	String& operator =(const String& other)
+	{
+		buffer_ = other.buffer_;
+
+		return *this;
+	}
+
+	/// \brief Equality comparison operator
+	///
+	/// For comparing this object to any of the data types we have a
+	/// compare() overload for.
+	template <typename T>
+	bool operator ==(const T& rhs) const
+	{
+		return compare(rhs) == 0;
+	}
+
+	/// \brief Equality comparison operator
+	///
+	/// For checking object against MySQL++'s global \c null constant
+	bool operator ==(const mysqlpp::null_type&) const
+	{
+		return is_null();
+	}
+
+	/// \brief Inequality comparison operator
+	///
+	/// For comparing this object to any of the data types we have a
+	/// compare() overload for.
+	template <typename T>
+	bool operator !=(const T& rhs) const
+	{
+		return compare(rhs) != 0;
+	}
+
+	/// \brief Inequality comparison operator
+	///
+	/// For checking object against MySQL++'s global \c null constant
+	bool operator !=(const mysqlpp::null_type&) const
+	{
+		return !is_null();
+	}
+
+	/// \brief Return a character within the string.
+	///
+	/// Unlike at(), this access method doesn't check the index for
+	/// sanity.
+	char operator [](size_type pos) const;
+
+	/// \brief Returns a const char pointer to the object's raw data
+	operator const char*() const { return data(); }
+	
+	/// \brief Converts this object's string data to a signed char
+	operator signed char() const
+			{ return conv(static_cast<signed char>(0)); }
+	
+	/// \brief Converts this object's string data to an unsigned char
+	operator unsigned char() const
+			{ return conv(static_cast<unsigned char>(0)); }
+	
+	/// \brief Converts this object's string data to an int
+	operator int() const
+			{ return conv(static_cast<int>(0)); }
+	
+	/// \brief Converts this object's string data to an unsigned int
+	operator unsigned int() const
+			{ return conv(static_cast<unsigned int>(0)); }
+	
+	/// \brief Converts this object's string data to a short int
+	operator short int() const
+			{ return conv(static_cast<short int>(0)); }
+	
+	/// \brief Converts this object's string data to an unsigned short
+	/// int
+	operator unsigned short int() const
+			{ return conv(static_cast<unsigned short int>(0)); }
+	
+	/// \brief Converts this object's string data to a long int
+	operator long int() const
+			{ return conv(static_cast<long int>(0)); }
+	
+	/// \brief Converts this object's string data to an unsigned long
+	/// int
+	operator unsigned long int() const
+			{ return conv(static_cast<unsigned long int>(0)); }
+	
+#if !defined(NO_LONG_LONGS)
+	/// \brief Converts this object's string data to the platform-
+	/// specific 'longlong' type, usually a 64-bit integer.
+	operator longlong() const
+			{ return conv(static_cast<longlong>(0)); }
+	
+	/// \brief Converts this object's string data to the platform-
+	/// specific 'ulonglong' type, usually a 64-bit unsigned integer.
+	operator ulonglong() const
+			{ return conv(static_cast<ulonglong>(0)); }
+#endif
+	
+	/// \brief Converts this object's string data to a float
+	operator float() const
+			{ return conv(static_cast<float>(0)); }
+	
+	/// \brief Converts this object's string data to a double
+	operator double() const
+			{ return conv(static_cast<double>(0)); }
+	
+	/// \brief Converts this object's string data to a bool
+	operator bool() const { return buffer_ ? atoi(c_str()) : false; }
+
+	/// \brief Converts this object's string data to a mysqlpp::Date
+	operator Date() const { return buffer_ ? Date(*this) : Date(); }
+
+	/// \brief Converts this object's string data to a mysqlpp::DateTime
+	operator DateTime() const
+			{ return buffer_ ? DateTime(*this) : DateTime(); }
+
+	/// \brief Converts this object's string data to a mysqlpp::Time
+	operator Time() const { return buffer_ ? Time(*this) : Time(); }
+
+	/// \brief Converts the String to a nullable data type
+	///
+	/// This is just an implicit version of conv(Null<T, B>)
+	template <class T, class B>
+	operator Null<T, B>() const { return conv(Null<T, B>()); }
+
+private:
+	/// \brief Do the actual numeric conversion via @p Type.
+	template <class Type>
+	Type do_conv(const char* type_name) const
+	{
+		if (buffer_) {
+			std::stringstream buf;
+			buf.write(data(), length());
+			buf.imbue(std::locale::classic()); // "C" locale
+			Type num = Type();
+			
+			if (buf >> num) {
+				char c;
+				if (!(buf >> c)) {
+					// Nothing left in buffer, so conversion complete,
+					// and thus successful.
+					return num;
+				}
+
+				if (c == '.' &&
+						(typeid(Type) != typeid(float)) &&
+						(typeid(Type) != typeid(double))) {
+					// Conversion stopped on a decimal point -- locale
+					// doesn't matter to MySQL -- so only way to succeed
+					// is if it's an integer and everything following
+					// the decimal is inconsequential.
+					c = '0';	// handles '.' at end of string
+					while (buf >> c && c == '0') /* spin */ ;
+					if (buf.eof() && c == '0') {
+						return num;  // only zeros after decimal point
+					}
+				}
+			}
+			else if (buf.eof()) {
+				return num;  // nothing to convert, return default value
+			}
+
+			throw BadConversion(type_name, data(), 0, length());
+		}
+		else {
+			return 0;
+		}
+	}
+
+	RefCountedBuffer buffer_;	///< reference-counted data buffer
+
+	friend class SQLTypeAdapter;
+};
+
+MYSQLPP_EXPORT std::ostream& operator <<(std::ostream& o,
+		const String& in);
+
+
+#if !defined(MYSQLPP_NO_BINARY_OPERS) && !defined(DOXYGEN_IGNORE)
+// Ignore this section is MYSQLPP_NO_BINARY_OPERS is defined, or if this
+// section is being parsed by Doxygen.  In the latter case, it's ignored
+// because Doxygen doesn't understand it correctly, and we can't be
+// bothered to explain it to Doxygen.
+
+#define oprsw(opr, other, conv) \
+	inline other operator opr (String x, other y) \
+			{ return static_cast<conv>(x) opr y; } \
+	inline other operator opr (other x, String y) \
+			{ return x opr static_cast<conv>(y); }
+
+#define operator_binary(other, conv) \
+  oprsw(+, other, conv) \
+  oprsw(-, other, conv) \
+  oprsw(*, other, conv) \
+  oprsw(/, other, conv)
+
+#define operator_binary_int(other, conv) \
+  operator_binary(other, conv) \
+  oprsw(%, other, conv) \
+  oprsw(&, other, conv) \
+  oprsw(^, other, conv) \
+  oprsw(|, other, conv) \
+  oprsw(<<, other, conv) \
+  oprsw(>>, other, conv)
+
+// Squish more complaints about possible loss of data
+#if defined(MYSQLPP_PLATFORM_VISUAL_CPP)
+#	pragma warning(disable: 4244)
+#endif
+
+operator_binary(float, double)
+operator_binary(double, double)
+
+operator_binary_int(char, long int)
+operator_binary_int(int, long int)
+operator_binary_int(short int, long int)
+operator_binary_int(long int, long int)
+
+operator_binary_int(unsigned char, unsigned long int)
+operator_binary_int(unsigned int, unsigned long int)
+operator_binary_int(unsigned short int, unsigned long int)
+operator_binary_int(unsigned long int, unsigned long int)
+
+#if defined(MYSQLPP_PLATFORM_VISUAL_CPP)
+#	pragma warning(default: 4244)
+#endif
+
+#if !defined(NO_LONG_LONGS)
+operator_binary_int(longlong, longlong)
+operator_binary_int(ulonglong, ulonglong)
+#endif // !defined(NO_LONG_LONGS)
+#endif // !defined(MYSQLPP_NO_BINARY_OPERS) && !defined(DOXYGEN_IGNORE)
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen isn't smart enough to recognize these template
+// specializations.  Maybe it's the MYSQLPP_EXPORT tags?
+
+/// \brief Specialization of String::conv<Type>() for bool
+///
+/// We can either do it this way, or define "\c strtob()" (string to
+/// bool, like \c strtol(), \c strtod()...) so we can use
+/// internal_string_to_number_proxy.
+template <> MYSQLPP_EXPORT bool String::conv(bool) const;
+
+/// \brief Specialization of String::conv<Type>() for String
+///
+/// Yes, I hear you crying, "WTF!?  Why does String need to be able to
+/// convert itself to String?"  SSQLSes with BLOB columns, that's why.
+///
+/// SSQLSes populate their data members from the raw field data by
+/// calling row["fieldname"].conv().  The raw field data is stored in a
+/// String, and the MySQL++ native BLOB type is String.  Since we're
+/// dealing with generated code, we need this specialization which hand-
+/// written code wouldn't need.  Prove the truth of this to yourself by
+/// removing this and counting how many pieces examples/cgi_jpeg.cpp
+/// breaks into.
+template <> MYSQLPP_EXPORT String String::conv(String) const;
+
+/// \brief Specialization of String::conv<Type>() for C++ strings
+template <> MYSQLPP_EXPORT std::string String::conv(std::string) const;
+
+/// \brief Specialization of String::conv<Type>() for mysqlpp::Date
+///
+/// This is necessary because as of MySQL++ v3, Date no longer has an
+/// implicit conversion ctor from String, and SSQLS uses conv() instead
+/// of the C++ type conversion system anyway.
+template <> MYSQLPP_EXPORT Date String::conv(Date) const;
+
+/// \brief Specialization of String::conv<Type>() for mysqlpp::DateTime
+///
+/// This is necessary because as of MySQL++ v3, DateTime no longer has
+/// an implicit conversion ctor from String, and SSQLS uses conv()
+/// instead of the C++ type conversion system anyway.
+template <> MYSQLPP_EXPORT DateTime String::conv(DateTime) const;
+
+/// \brief Specialization of String::conv<Type>() for mysqlpp::Time
+///
+/// This is necessary because as of MySQL++ v3, Time no longer has an
+/// implicit conversion ctor from String, and SSQLS uses conv() instead
+/// of the C++ type conversion system anyway.
+template <> MYSQLPP_EXPORT Time String::conv(Time) const;
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_MYSTRING_H)

ADDED   lib/noexceptions.h
Index: lib/noexceptions.h
==================================================================
--- /dev/null
+++ lib/noexceptions.h
@@ -0,0 +1,155 @@
+/// \file noexceptions.h
+/// \brief Declares interface that allows exceptions to be optional
+///
+/// A class may inherit from OptionalExceptions, which will add to it
+/// a mechanism by which a user can tell objects of that class to
+/// suppress exceptions.  (They are enabled by default.)  This module
+/// also declares a NoExceptions class, objects of which take a
+/// reference to any class derived from OptionalExceptions.  The
+/// NoExceptions constructor calls the method that disables exceptions,
+/// and the destructor reverts them to the previous state.  One uses
+/// the NoExceptions object within a scope to suppress exceptions in
+/// that block, without having to worry about reverting the setting when
+/// the block exits.
+
+/***********************************************************************
+ Copyright (c) 2005-2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#ifndef MYSQLPP_NOEXCEPTIONS_H
+#define MYSQLPP_NOEXCEPTIONS_H
+
+#include "common.h"
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class MYSQLPP_EXPORT NoExceptions;
+#endif
+
+/// \brief Interface allowing a class to have optional exceptions.
+///
+/// A class derives from this one to acquire a standard interface for
+/// disabling exceptions, possibly only temporarily.  By default,
+/// exceptions are enabled.
+///
+/// Note that all methods are const even though some of them change our
+/// internal flag indicating whether exceptions should be thrown.  This
+/// is justifiable because this is just an interface class, and it
+/// changes the behavior of our subclass literally only in exceptional
+/// conditions.  This Jesuitical interpretation of "const" is required
+/// because you may want to disable exceptions on const subclass
+/// instances.
+///
+/// If it makes you feel better about this, consider that the real
+/// change isn't within the const OptionalExceptions subclass instance.
+/// What changes is the code wrapping the method call on that instance
+/// that can optionally throw an exception.  This outside code is in
+/// a better position to say what "const" means than the subclass
+/// instance.
+
+class MYSQLPP_EXPORT OptionalExceptions
+{
+public:
+	/// \brief Default constructor
+	///
+	/// \param e if true, exceptions are enabled (this is the default)
+	OptionalExceptions(bool e = true) :
+	exceptions_(e)
+	{
+	}
+
+	/// \brief Destroy object
+	virtual ~OptionalExceptions() { }
+
+	/// \brief Enable exceptions from the object
+	void enable_exceptions() const { exceptions_ = true; }
+
+	/// \brief Disable exceptions from the object
+	void disable_exceptions() const { exceptions_ = false; }
+
+	/// \brief Returns true if exceptions are enabled
+	bool throw_exceptions() const { return exceptions_; }
+
+protected:
+	/// \brief Sets the exception state to a particular value
+	///
+	/// This method is protected because it is only intended for use by
+	/// subclasses' copy constructors and the like.
+	void set_exceptions(bool e) const { exceptions_ = e; }
+
+	/// \brief Declare NoExceptions to be our friend so it can access
+	/// our protected functions.
+	friend class NoExceptions;
+
+private:
+	mutable bool exceptions_;
+};
+
+
+/// \brief Disable exceptions in an object derived from
+/// OptionalExceptions.
+///
+/// This class was designed to be created on the stack, taking a
+/// reference to a subclass of OptionalExceptions. (We call that our
+/// "associate" object.) On creation, we save that object's current
+/// exception state, and disable exceptions. On destruction, we restore
+/// our associate's previous state.
+
+class MYSQLPP_EXPORT NoExceptions
+{
+public:
+	/// \brief Constructor
+	///
+	/// Takes a reference to an OptionalExceptions derivative,
+	/// saves that object's current exception state, and disables
+	/// exceptions.
+	NoExceptions(const OptionalExceptions& a) :
+	assoc_(a),
+	exceptions_were_enabled_(a.throw_exceptions())
+	{
+		assoc_.disable_exceptions();
+	}
+
+	/// \brief Destructor
+	///
+	/// Restores our associate object's previous exception state.
+	~NoExceptions()
+	{
+		assoc_.set_exceptions(exceptions_were_enabled_);
+	}
+	
+private:
+	const OptionalExceptions& assoc_;
+	bool exceptions_were_enabled_;
+
+	// Hidden assignment operator and copy ctor, because we should not
+	// be copied.
+	NoExceptions(const NoExceptions&);
+	NoExceptions& operator=(const NoExceptions&);
+};
+
+} // end namespace mysqlpp
+
+#endif // MYSQLPP_NOEXCEPTIONS_H
+

ADDED   lib/null.cpp
Index: lib/null.cpp
==================================================================
--- /dev/null
+++ lib/null.cpp
@@ -0,0 +1,32 @@
+/***********************************************************************
+ null.cpp - Defines a few things declared in null.h
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "null.h"
+
+namespace mysqlpp {
+	/// \brief "NULL" string constant used in many places within MySQL++
+	const std::string null_str("NULL");
+}
+

ADDED   lib/null.h
Index: lib/null.h
==================================================================
--- /dev/null
+++ lib/null.h
@@ -0,0 +1,356 @@
+/// \file null.h
+/// \brief Declares classes that implement SQL "null" semantics within
+/// C++'s type system.
+///
+/// This is required because C++'s own NULL type is not semantically
+/// the same as SQL nulls.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#ifndef MYSQLPP_NULL_H
+#define MYSQLPP_NULL_H
+
+#include "exceptions.h"
+
+#include <iostream>
+#include <string>
+
+namespace mysqlpp {
+
+extern const std::string null_str;	///< "NULL" string constant
+
+
+/// \brief The type of the global mysqlpp::null object.
+///
+/// User code shouldn't declare variables of this type.  Use the
+/// Null template instead.
+class MYSQLPP_EXPORT null_type
+{
+protected:
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+	template <typename CannotConvertNullToAnyOtherDataType>
+	operator CannotConvertNullToAnyOtherDataType() const
+	{
+		return CannotConvertNullToAnyOtherDataType();
+	}
+#endif // !defined(DOXYGEN_IGNORE)
+};
+
+/// \brief Global 'null' instance.  Use wherever you need a SQL null.
+///
+/// SQL null is equal to nothing else.  It is not the same as C++'s
+/// NULL value, it is not a Boolean false....it is unique.  As such, if
+/// you use this in some other type context, you will get a compiler
+/// error saying something about \c CannotConvertNullToAnyOtherDataType.
+/// The only thing you can assign this object instance to is a variable
+/// of type Null<T>, and then only directly.  Code like this does not
+/// work:
+///
+/// \code
+/// int foo = return_some_value_for_foo();
+/// mysqlpp::Null<int> bar = foo ? foo : mysqlpp::null;
+/// \endcode
+/// 
+/// The compiler will try to convert mysqlpp::null to \c int to make
+/// all values in the conditional operation consistent, but this is
+/// not legal.  Anyway, it's questionable code because it means you're
+/// using SQL null to mean the same thing as zero here.  If zero is a
+/// special value, there's no reason to use SQL null.  SQL null exists
+/// when every value for a particular column is legal and you need
+/// something that means "no legal value".
+const null_type null = null_type();
+
+
+/// \brief Class for objects that define SQL null in terms of
+/// MySQL++'s null_type.
+///
+/// Returns a null_type instance when you ask what null is, and is
+/// "(NULL)" when you insert it into a C++ stream.
+///
+/// Used for the behavior parameter for template Null
+struct NullIsNull
+{
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+	static null_type null_is() { return null; }
+
+	static std::ostream& null_ostr(std::ostream& o)
+	{
+		o << "(NULL)";
+		return o;
+	}
+#endif // !defined(DOXYGEN_IGNORE)
+};
+
+
+/// \brief Class for objects that define SQL null as 0.
+///
+/// Returns 0 when you ask what null is, and is zero when you insert it
+/// into a C++ stream.
+///
+/// Used for the behavior parameter for template Null
+struct NullIsZero
+{
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+	static int null_is() { return 0; }
+	
+	static std::ostream& null_ostr(std::ostream& o)
+	{
+		o << 0;
+		return o;
+	}
+#endif // !defined(DOXYGEN_IGNORE)
+};
+
+/// \brief Class for objects that define SQL null as a blank C string.
+///
+/// Returns "" when you ask what null is, and is empty when you insert
+/// it into a C++ stream.
+///
+/// Used for the behavior parameter for template Null
+struct NullIsBlank
+{
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+	static const char *null_is() { return ""; }
+	
+	static std::ostream& null_ostr(std::ostream& o)
+	{
+		o << "";
+		return o;
+	}
+#endif // !defined(DOXYGEN_IGNORE)
+};
+
+
+/// \brief Class for holding data from a SQL column with the NULL
+/// attribute.
+///
+/// This template is necessary because there is nothing in the C++ type
+/// system with the same semantics as SQL's null.  In SQL, a column can
+/// have the optional 'NULL' attribute, so there is a difference in 
+/// type between, say an \c int column that can be null and one that
+/// cannot be.  C++'s NULL constant does not have these features.
+///
+/// It's important to realize that this class doesn't hold nulls,
+/// it holds data that \e can \e be null.  It can hold a non-null
+/// value, you can then assign null to it (using MySQL++'s global
+/// \c null object), and then assign a regular value to it again; the
+/// object will behave as you expect throughout this process.
+///
+/// Because one of the template parameters is a C++ type, the typeid()
+/// for a null \c int is different than for a null \c string, to pick
+/// two random examples.  See type_info.cpp for the table SQL types that
+/// can be null.
+template <class Type, class Behavior = NullIsNull> class Null
+{
+public:
+	/// \brief The object's value, when it is not SQL null
+	Type data;
+	
+	/// \brief If set, this object is considered equal to SQL null.
+	///
+	/// This flag affects how the Type() and << operators work.
+	bool is_null;
+
+	/// \brief Type of the data stored in this object, when it is not
+	/// equal to SQL null.
+	typedef Type value_type;
+
+	/// \brief Default constructor
+	///
+	/// "data" member is left uninitialized by this ctor, because we
+	/// don't know what to initialize it to.
+	Null() :
+	is_null(false)
+	{
+	}
+
+	/// \brief Initialize the object with a particular value.
+	///
+	/// The object is marked as "not null" if you use this ctor.  This
+	/// behavior exists because the class doesn't encode nulls, but
+	/// rather data which \e can \e be null.  The distinction is
+	/// necessary because 'NULL' is an optional attribute of SQL
+	/// columns.
+	Null(const Type& x) :
+	data(x),
+	is_null(false)
+	{
+	}
+
+	/// \brief Construct a Null equal to SQL null
+	///
+	/// This is typically used with the global \c null object. (Not to
+	/// be confused with C's NULL type.)  You can say something like...
+	/// \code
+	/// Null<int> foo = null;
+	/// \endcode
+	/// ...to get a null \c int.
+	Null(const null_type&) :
+	is_null(true)
+	{
+	}
+
+	/// \brief Converts this object to Type
+	///
+	/// If is_null is set, returns whatever we consider that null "is",
+	/// according to the Behavior parameter you used when instantiating
+	/// this template.  See NullIsNull, NullIsZero and NullIsBlank.
+	///
+	/// Otherwise, just returns the 'data' member.
+	operator Type&()
+	{
+		if (is_null)
+			return data = Behavior::null_is();
+		else
+			return data;
+	}
+
+	/// \brief Assign a value to the object.
+	///
+	/// This marks the object as "not null" as a side effect.
+	Null& operator =(const Type& x)
+	{
+		data = x;
+		is_null = false;
+		return *this;
+	}
+
+	/// \brief Assign SQL null to this object.
+	///
+	/// This just sets the is_null flag; the data member is not
+	/// affected until you call the Type() operator on it.
+	Null& operator =(const null_type& n)
+	{
+		is_null = true;
+		return *this;
+	}
+
+	/// \brief Do equality comparison of two nullable values
+	///
+	/// Two null objects are equal, and null is not equal to not-null.
+	/// If neither is null, we delegate to operator == for the base
+	/// data type.
+	bool operator ==(const Null<Type>& rhs) const
+	{
+		if (is_null && rhs.is_null) {
+			return true;
+		}
+		else if (is_null != rhs.is_null) {
+			return false;	// one null, the other not
+		}
+		else {
+			return data == rhs.data;
+		}
+	}
+
+	/// \brief Do equality comparison against hard-coded SQL null
+	///
+	/// This tells you the same thing as testing is_null member.
+	bool operator ==(const null_type&) const { return is_null; }
+
+	/// \brief Do inequality comparison of two nullable values
+	bool operator !=(const Null<Type>& rhs) const
+			{ return !(*this == rhs); }
+
+	/// \brief Do inequality comparison against hard-coded SQL null
+	bool operator !=(const null_type& rhs) const
+			{ return !(*this == rhs); }
+
+	/// \brief Do less-than comparison of two nullable values
+	///
+	/// Two null objects are equal to each other, and null is less
+	/// than not-null.  If neither is null, we delegate to operator <
+	/// for the base data type.
+	bool operator <(const Null<Type>& rhs) const
+	{
+		if (is_null && rhs.is_null) {
+			return false;
+		}
+		else if (is_null && !rhs.is_null) {
+			return true;
+		}
+		else {
+			return data < rhs.data;
+		}
+	}
+
+	/// \brief Do less-than comparison against hard-coded SQL null
+	///
+	/// Always returns false because we can only be greater than or
+	/// equal to a SQL null.
+	bool operator <(const null_type&) const { return false; }
+};
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+// Specialization the Null template for \c void
+template <> class Null<void>
+{
+public:
+	bool is_null;
+	typedef void value_type;
+
+	Null() :
+	is_null(false)
+	{
+	}
+	
+	Null(const null_type&) :
+	is_null(true)
+	{
+	}
+
+	Null& operator =(const null_type&)
+	{
+		is_null = true;
+		return *this;
+	}
+};
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+/// \brief Inserts null-able data into a C++ stream if it is not
+/// actually null.  Otherwise, insert something appropriate for null
+/// data.
+template <class Type, class Behavior>
+inline std::ostream& operator <<(std::ostream& o,
+		const Null<Type, Behavior>& n)
+{
+	if (n.is_null)
+		return Behavior::null_ostr(o);
+	else
+		return o << n.data;
+}
+
+} // end namespace mysqlpp
+
+#endif

ADDED   lib/options.cpp
Index: lib/options.cpp
==================================================================
--- /dev/null
+++ lib/options.cpp
@@ -0,0 +1,360 @@
+/***********************************************************************
+ options.cpp - Implements the Option class hierarchy.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others
+ may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "options.h"
+
+#include "dbdriver.h"
+
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// We're hiding all the Option subclass internals from Doxygen.  All the
+// upper-level classes are documented fully, and each leaf class itself
+// is documented.  It's just the ctors and set() methods we're refusing
+// to document over and over again.
+
+Option::Error
+CompressOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_COMPRESS) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+ConnectTimeoutOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_CONNECT_TIMEOUT, &arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+FoundRowsOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(CLIENT_FOUND_ROWS, arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+GuessConnectionOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_GUESS_CONNECTION) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+IgnoreSpaceOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(CLIENT_IGNORE_SPACE, arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+InitCommandOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_INIT_COMMAND, arg_.c_str()) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+InteractiveOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(CLIENT_INTERACTIVE, arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+LocalFilesOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(CLIENT_LOCAL_FILES, arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+LocalInfileOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_LOCAL_INFILE, &arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+MultiResultsOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	if (dbd->connected()) {
+		return dbd->set_option(arg_ ? MYSQL_OPTION_MULTI_STATEMENTS_ON :
+				MYSQL_OPTION_MULTI_STATEMENTS_OFF) ?
+				Option::err_NONE : Option::err_api_reject;
+	}
+	else {
+		return dbd->set_option(CLIENT_MULTI_RESULTS, arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+	}
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+MultiStatementsOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	if (dbd->connected()) {
+		return dbd->set_option(arg_ ? MYSQL_OPTION_MULTI_STATEMENTS_ON :
+				MYSQL_OPTION_MULTI_STATEMENTS_OFF) ?
+				Option::err_NONE : Option::err_api_reject;
+	}
+	else {
+		return dbd->set_option(CLIENT_MULTI_STATEMENTS, arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+	}
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+NamedPipeOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_NAMED_PIPE) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+NoSchemaOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(CLIENT_NO_SCHEMA, arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+#if MYSQL_VERSION_ID > 40000		// only in 4.0 +
+Option::Error
+ProtocolOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_PROTOCOL, &arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+#endif
+
+
+Option::Error
+ReadDefaultFileOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_READ_DEFAULT_FILE, arg_.c_str()) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+ReadDefaultGroupOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_READ_DEFAULT_GROUP, arg_.c_str()) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+ReadTimeoutOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_READ_TIMEOUT, &arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+ReconnectOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 50013
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_RECONNECT, &arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+ReportDataTruncationOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 50003
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_REPORT_DATA_TRUNCATION, &arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+SecureAuthOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_SECURE_AUTH, &arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+SetCharsetDirOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_SET_CHARSET_DIR, arg_.c_str()) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+SetCharsetNameOption::set(DBDriver* dbd)
+{
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_SET_CHARSET_NAME, arg_.c_str()) ?
+				Option::err_NONE : Option::err_api_reject;
+}
+
+
+Option::Error
+SetClientIpOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_SET_CLIENT_IP, arg_.c_str()) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+SharedMemoryBaseNameOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40100
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_SHARED_MEMORY_BASE_NAME, arg_.c_str()) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+SslOption::set(DBDriver* dbd)
+{
+#if defined(HAVE_MYSQL_SSL_SET)
+	return dbd->connected() ? Option::err_connected :
+			dbd->enable_ssl(key_.c_str(), cert_.c_str(), ca_.c_str(),
+				capath_.c_str(), cipher_.c_str()) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+UseEmbeddedConnectionOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_USE_EMBEDDED_CONNECTION) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+UseRemoteConnectionOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_USE_REMOTE_CONNECTION) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+
+Option::Error
+WriteTimeoutOption::set(DBDriver* dbd)
+{
+#if MYSQL_VERSION_ID >= 40101
+	return dbd->connected() ? Option::err_connected :
+			dbd->set_option(MYSQL_OPT_WRITE_TIMEOUT, &arg_) ?
+				Option::err_NONE : Option::err_api_reject;
+#else
+	return Option::err_api_limit;
+#endif
+}
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+} // end namespace mysqlpp

ADDED   lib/options.h
Index: lib/options.h
==================================================================
--- /dev/null
+++ lib/options.h
@@ -0,0 +1,496 @@
+/// \file options.h
+/// \brief Declares the Option class hierarchy, used to implement
+/// connection options in Connection and DBDriver classes.
+///
+/// This is tied closely enough to DBDriver that there's a pure-OO
+/// argument that it should be declared as protected or private members
+/// within DBDriver.  We do it outside DBDriver because there's so much
+/// of it.  It'd overwhelm everything else that's going on in that class
+/// totally out of proprortion to the importance of options.
+
+/***********************************************************************
+ Copyright (c) 2007 by Educational Technology Resources, Inc.  Others
+ may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_OPTIONS_H)
+#define MYSQLPP_OPTIONS_H
+
+#include "common.h"
+
+#include <deque>
+#include <string>
+
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+class DBDriver;
+#endif
+
+
+////////////////////////////////////////////////////////////////////////
+// Classes
+
+/// \brief Define abstract interface for all *Option subclasses.
+///
+/// This is the base class for the mid-level interface classes that take
+/// arguments, plus the direct base for options that take no arguments.
+class MYSQLPP_EXPORT Option
+{
+public:
+	/// \brief Types of option setting errors we can diagnose
+	enum Error {
+		err_NONE,		///< option was set successfully
+		err_api_limit,	///< option not supported by underlying C API
+		err_api_reject,	///< underlying C API returned error when setting option
+		err_connected	///< can't set the given option while connected
+	};
+	
+	virtual ~Option() { }					///< Destroy object
+	virtual Error set(DBDriver* dbd) = 0;	///< Apply option
+};
+
+
+/// \brief Define abstract interface for all *Options that take a
+/// lone scalar as an argument.
+template <typename T>
+class MYSQLPP_EXPORT DataOption : public Option
+{
+public:
+	typedef T ArgType;						///< Alias for template param
+
+protected:
+	DataOption(const T& arg) : arg_(arg) { }///< Construct object
+	T arg_;									///< The argument value
+};
+
+typedef DataOption<unsigned> IntegerOption;		///< Option w/ int argument
+typedef DataOption<bool> BooleanOption;			///< Option w/ bool argument
+typedef DataOption<std::string> StringOption;	///< Option w/ string argument
+
+
+/// \brief Enable data compression on the connection
+class MYSQLPP_EXPORT CompressOption : public Option
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	CompressOption() : Option() { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Change Connection::connect() default timeout
+class MYSQLPP_EXPORT ConnectTimeoutOption : public IntegerOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	ConnectTimeoutOption(ArgType arg) : IntegerOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Make Query::affected_rows() return number of matched rows
+///
+/// Default is to return number of \b changed rows.
+class MYSQLPP_EXPORT FoundRowsOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	FoundRowsOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Allow C API to guess what kind of connection to use
+///
+/// This is the default.  The option exists to override
+/// UseEmbeddedConnectionOption and UseEmbeddedConnectionOption.
+class MYSQLPP_EXPORT GuessConnectionOption : public Option
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	GuessConnectionOption() : Option() { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Allow spaces after function names in queries
+class MYSQLPP_EXPORT IgnoreSpaceOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	IgnoreSpaceOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Give SQL executed on connect
+class MYSQLPP_EXPORT InitCommandOption : public StringOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	InitCommandOption(ArgType arg) : StringOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Assert that this is an interactive program
+///
+/// Affects connection timeouts.
+class MYSQLPP_EXPORT InteractiveOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	InteractiveOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Enable LOAD DATA LOCAL statement
+class MYSQLPP_EXPORT LocalFilesOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	LocalFilesOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Enable LOAD LOCAL INFILE statement
+class MYSQLPP_EXPORT LocalInfileOption : public IntegerOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	LocalInfileOption(ArgType arg) : IntegerOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Enable multiple result sets in a reply
+class MYSQLPP_EXPORT MultiResultsOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	MultiResultsOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Enable multiple queries in a request to the server
+class MYSQLPP_EXPORT MultiStatementsOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	MultiStatementsOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Suggest use of named pipes
+class MYSQLPP_EXPORT NamedPipeOption : public Option
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	NamedPipeOption() : Option() { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Disable db.tbl.col syntax in queries
+class MYSQLPP_EXPORT NoSchemaOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	NoSchemaOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+#if MYSQL_VERSION_ID > 40000		// only in 4.0 +
+/// \brief Set type of protocol to use
+class MYSQLPP_EXPORT ProtocolOption : public IntegerOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	ProtocolOption(ArgType arg) : IntegerOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+#endif
+
+
+/// \brief Override use of my.cnf
+class MYSQLPP_EXPORT ReadDefaultFileOption : public StringOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	ReadDefaultFileOption(ArgType arg) : StringOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Override use of my.cnf
+class MYSQLPP_EXPORT ReadDefaultGroupOption : public StringOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	ReadDefaultGroupOption(ArgType arg) : StringOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Set timeout for IPC data reads
+class MYSQLPP_EXPORT ReadTimeoutOption : public IntegerOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	ReadTimeoutOption(ArgType arg) : IntegerOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Enable automatic reconnection to server
+class MYSQLPP_EXPORT ReconnectOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	ReconnectOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Set reporting of data truncation errors
+class MYSQLPP_EXPORT ReportDataTruncationOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	ReportDataTruncationOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Enforce use of secure authentication, refusing connection if
+/// not available
+class MYSQLPP_EXPORT SecureAuthOption : public BooleanOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	SecureAuthOption(ArgType arg) : BooleanOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Give path to charset definition files
+class MYSQLPP_EXPORT SetCharsetDirOption : public StringOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	SetCharsetDirOption(ArgType arg) : StringOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Give name of default charset
+class MYSQLPP_EXPORT SetCharsetNameOption : public StringOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	SetCharsetNameOption(ArgType arg) : StringOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Fake client IP address when connecting to embedded server
+class MYSQLPP_EXPORT SetClientIpOption : public StringOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	SetClientIpOption(ArgType arg) : StringOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Set name of shmem segment for IPC
+class MYSQLPP_EXPORT SharedMemoryBaseNameOption : public StringOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	SharedMemoryBaseNameOption(ArgType arg) : StringOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Specialized option for handling SSL parameters.
+class MYSQLPP_EXPORT SslOption : public Option
+{
+public:
+	/// \brief Create a set of SSL connection option parameters
+	///
+	/// \param key the pathname to the key file
+	/// \param cert the pathname to the certificate file
+	/// \param ca the pathname to the certificate authority file
+	/// \param capath directory that contains trusted SSL CA
+	///        certificates in pem format.
+    /// \param cipher list of allowable ciphers to use
+	///
+	/// This option replaces \c Connection::enable_ssl() from MySQL++
+	/// version 2.  Now you can set this connection option just like any
+	/// other.
+ 	SslOption(const char* key = 0, const char* cert = 0,
+			const char* ca = 0, const char* capath = 0,
+			const char* cipher = 0)
+	{
+		if (key)	key_.assign(key);
+		if (cert)	cert_.assign(key);
+		if (ca)		ca_.assign(key);
+		if (capath)	capath_.assign(key);
+		if (cipher)	cipher_.assign(key);
+	}
+
+private:
+	std::string key_, cert_, ca_, capath_, cipher_;
+	Error set(DBDriver* dbd);
+};
+
+
+/// \brief Connect to embedded  server in preference to remote server
+class MYSQLPP_EXPORT UseEmbeddedConnectionOption : public Option
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	UseEmbeddedConnectionOption() : Option() { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Connect to remote server in preference to embedded server
+class MYSQLPP_EXPORT UseRemoteConnectionOption : public Option
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	UseRemoteConnectionOption() : Option() { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+/// \brief Set timeout for IPC data reads
+class MYSQLPP_EXPORT WriteTimeoutOption : public IntegerOption
+{
+#if !defined(DOXYGEN_IGNORE)
+public:
+	WriteTimeoutOption(ArgType arg) : IntegerOption(arg) { }
+
+private:
+	Error set(DBDriver* dbd);
+#endif
+};
+
+
+////////////////////////////////////////////////////////////////////////
+// Typedefs
+
+/// \brief The data type of the list of connection options
+typedef std::deque<Option*> OptionList;
+
+/// \brief Primary iterator type into List
+typedef OptionList::const_iterator OptionListIt;
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_OPTIONS_H)

ADDED   lib/qparms.cpp
Index: lib/qparms.cpp
==================================================================
--- /dev/null
+++ lib/qparms.cpp
@@ -0,0 +1,83 @@
+/***********************************************************************
+ qparms.cpp - Implements the SQLQueryParms class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
+ MySQL AB, and (c) 2004-2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "qparms.h"
+
+#include "query.h"
+
+using namespace std;
+
+namespace mysqlpp {
+
+size_t
+SQLQueryParms::escape_string(std::string* ps, const char* original,
+		size_t length) const
+{
+	return parent_ ? parent_->escape_string(ps, original, length) : 0;
+}
+
+size_t
+SQLQueryParms::escape_string(char* escaped, const char* original,
+		size_t length) const
+{
+	return parent_ ? parent_->escape_string(escaped, original, length) : 0;
+}
+
+SQLTypeAdapter&
+SQLQueryParms::operator [](const char* str)
+{
+	if (parent_) {
+		return operator [](parent_->parsed_nums_[str]);
+	}
+	throw ObjectNotInitialized("SQLQueryParms object has no parent!");
+}
+
+const SQLTypeAdapter&
+SQLQueryParms::operator[] (const char* str) const
+{
+	if (parent_) {
+		return operator [](parent_->parsed_nums_[str]);
+	}
+	throw ObjectNotInitialized("SQLQueryParms object has no parent!");
+}
+
+SQLQueryParms
+SQLQueryParms::operator +(const SQLQueryParms& other) const
+{
+	if (other.size() <= size()) {
+		return *this;
+	}
+	SQLQueryParms New = *this;
+	size_t i;
+	for (i = size(); i < other.size(); i++) {
+		New.push_back(other[i]);
+	}
+
+	return New;
+}
+
+
+} // end namespace mysqlpp

ADDED   lib/qparms.h
Index: lib/qparms.h
==================================================================
--- /dev/null
+++ lib/qparms.h
@@ -0,0 +1,266 @@
+/// \file qparms.h
+/// \brief Declares the template query parameter-related stuff.
+///
+/// The classes defined in this file are used by class Query when it
+/// parses a template query: they hold information that it finds in the
+/// template, so it can assemble a SQL statement later on demand.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#ifndef MYSQLPP_QPARMS_H
+#define MYSQLPP_QPARMS_H
+
+#include "stadapter.h"
+
+#include <vector>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class MYSQLPP_EXPORT Query;
+#endif
+
+/// \brief This class holds the parameter values for filling
+/// template queries. 
+class MYSQLPP_EXPORT SQLQueryParms : public std::vector<SQLTypeAdapter>
+{
+public:
+	/// \brief Abbreviation so some of the declarations below don't
+	/// span many lines.
+	typedef const SQLTypeAdapter& sta;
+
+	/// \brief Default constructor
+	SQLQueryParms() :
+	parent_(0),
+	processing_(false)
+	{
+	}
+	
+	/// \brief Create object
+	///
+	/// \param p pointer to the query object these parameters are tied
+	/// to
+	SQLQueryParms(Query* p) :
+	parent_(p),
+	processing_(false)
+	{
+	}
+	
+	/// \brief Returns true if we are bound to a query object.
+	///
+	/// Basically, this tells you which of the two ctors were called.
+	bool bound() { return parent_ != 0; }
+
+	/// \brief Clears the list
+	void clear() { erase(begin(), end()); }
+
+	/// \brief Indirect access to Query::escape_string()
+	///
+	/// \internal Needed by \c operator<<(Manip&, \c const \c T&) where
+	/// \c Manip is used on a SQLQueryParms object.  We'd have to make
+	/// all these operators friends to give access to our internal Query
+	/// object otherwise.
+	///
+	/// \see Query::escape_string(std::string*, const char*, size_t)
+	size_t escape_string(std::string* ps, const char* original = 0,
+			size_t length = 0) const;
+
+	/// \brief Indirect access to Query::escape_string()
+	///
+	/// \see escape_string(std::string*, const char*, size_t)
+	/// \see Query::escape_string(const char*, const char*, size_t)
+	size_t escape_string(char* escaped, const char* original,
+			size_t length) const;
+
+	/// \brief Access element number n
+	SQLTypeAdapter& operator [](size_type n)
+	{
+		if (n >= size()) {
+			insert(end(), (n + 1) - size(), "");
+		}
+		return std::vector<SQLTypeAdapter>::operator [](n);
+	}
+
+	/// \brief Access element number n
+	const SQLTypeAdapter& operator [](size_type n) const
+			{ return std::vector<SQLTypeAdapter>::operator [](n); }
+	
+	/// \brief Access the value of the element with a key of str.
+	SQLTypeAdapter& operator [](const char *str);
+
+	/// \brief Access the value of the element with a key of str.
+	const SQLTypeAdapter& operator [](const char *str) const;
+
+	/// \brief Adds an element to the list
+	SQLQueryParms& operator <<(const SQLTypeAdapter& str)
+	{
+		push_back(str);
+		return *this;
+	}
+
+	/// \brief Adds an element to the list
+	SQLQueryParms& operator +=(const SQLTypeAdapter& str)
+	{
+		push_back(str);
+		return *this;
+	}
+
+	/// \brief Build a composite of two parameter lists
+	///
+	/// If this list is (a, b) and \c other is (c, d, e, f, g), then
+	/// the returned list will be (a, b, e, f, g).  That is, all of this
+	/// list's parameters are in the returned list, plus any from the
+	/// other list that are in positions beyond what exist in this list.
+	///
+	/// If the two lists are the same length or this list is longer than
+	/// the \c other list, a copy of this list is returned.
+	SQLQueryParms operator +(
+			const SQLQueryParms& other) const;
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+	void set(sta a)
+	{
+		clear();
+		*this << a;
+	}
+	void set(sta a, sta b)
+	{
+		clear();
+		*this << a << b;
+	}
+	void set(sta a, sta b, sta c)
+	{
+		clear();
+		*this << a << b << c;
+	}
+	void set(sta a, sta b, sta c, sta d)
+	{
+		clear();
+		*this << a << b << c << d;
+	}
+	void set(sta a, sta b, sta c, sta d, sta e)
+	{
+		clear();
+		*this << a << b << c << d << e;
+	}
+	void set(sta a, sta b, sta c, sta d, sta e, sta f)
+	{
+		clear();
+		*this << a << b << c << d << e << f;
+	}
+	void set(sta a, sta b, sta c, sta d, sta e, sta f, sta g)
+	{
+		clear();
+		*this << a << b << c << d << e << f << g;
+	}
+	void set(sta a, sta b, sta c, sta d, sta e, sta f, sta g, sta h)
+	{
+		clear();
+		*this << a << b << c << d << e << f << g << h;
+	}
+	void set(sta a, sta b, sta c, sta d, sta e, sta f, sta g, sta h, sta i)
+	{
+		clear();
+		*this << a << b << c << d << e << f << g << h << i;
+	}
+	void set(sta a, sta b, sta c, sta d, sta e, sta f, sta g, sta h, sta i, sta j)
+	{
+		clear();
+		*this << a << b << c << d << e << f << g << h << i << j;
+	}
+	void set(sta a, sta b, sta c, sta d, sta e, sta f, sta g, sta h, sta i, sta j, sta k)
+	{
+		clear();
+		*this << a << b << c << d << e << f << g << h << i << j << k;
+	}
+#endif // !defined(DOXYGEN_IGNORE)
+
+	/// \brief Set the template query parameters.
+	///
+	/// Sets parameter 0 to a, parameter 1 to b, etc. There are
+	/// overloaded versions of this function that take anywhere from
+	/// one to a dozen parameters.
+	void set(sta a, sta b, sta c, sta d, sta e, sta f, sta g,
+			sta h, sta i, sta j, sta k, sta l)
+	{
+		clear();
+		*this << a << b << c << d << e << f << g << h << i << j << k << l;
+	}
+
+private:
+	friend class Query;
+
+	Query* parent_;
+	bool processing_;	///< true if we're building a query string
+};
+
+
+/// \brief Used within Query to hold elements for parameterized
+/// queries.
+///
+/// Each element has three parts:
+///
+/// The concept behind the \c before variable needs a little explaining.
+/// When a template query is parsed, each parameter is parsed into one
+/// of these SQLParseElement objects, but the non-parameter parts of the
+/// template also have to be stored somewhere.  MySQL++ chooses to
+/// attach the text leading up to a parameter to that parameter.  So,
+/// the \c before string is simply the text copied literally into the
+/// finished query before we insert a value for the parameter.
+///
+/// The \c option character is currently one of 'q', 'Q', 'r', 'R' or
+/// ' '.  See the "Template Queries" chapter in the user manual for
+/// details.
+///
+/// The position value (\c num) allows a template query to have its
+/// parameters in a different order than in the Query method call.
+/// An example of how this can be helpful is in the "Template Queries"
+/// chapter of the user manual.
+
+struct SQLParseElement
+{
+	/// \brief Create object
+	///
+	/// \param b the 'before' value
+	/// \param o the 'option' value
+	/// \param n the 'num' value
+	SQLParseElement(std::string b, char o, signed char n) :
+	before(b),
+	option(o),
+	num(n)
+	{
+	}
+	
+	std::string before;		///< string inserted before the parameter
+	char option;			///< the parameter option, or blank if none
+	signed char num;		///< the parameter position to use
+};
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_QPARMS_H)
+

ADDED   lib/query.cpp
Index: lib/query.cpp
==================================================================
--- /dev/null
+++ lib/query.cpp
@@ -0,0 +1,633 @@
+/***********************************************************************
+ query.cpp - Implements the Query class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "query.h"
+
+#include "autoflag.h"
+#include "dbdriver.h"
+#include "connection.h"
+
+namespace mysqlpp {
+
+Query::Query(Connection* c, bool te, const char* qstr) :
+#if defined(MYSQLPP_HAVE_STD__NOINIT)
+// prevents a double-init memory leak in native VC++ RTL (not STLport!)
+std::ostream(std::_Noinit), 
+#else
+std::ostream(0),
+#endif
+OptionalExceptions(te),
+template_defaults(this),
+conn_(c),
+copacetic_(true)
+{
+	init(&sbuffer_);
+	if (qstr) {
+		sbuffer_.str(qstr);
+	}
+}
+
+Query::Query(const Query& q) :
+#if defined(MYSQLPP_HAVE_STD__NOINIT)
+// ditto above
+std::ostream(std::_Noinit),
+#else
+std::ostream(0),
+#endif
+OptionalExceptions(q.throw_exceptions()),
+template_defaults(q.template_defaults),
+conn_(q.conn_),
+copacetic_(q.copacetic_)
+{
+	// We don't copy stream buffer or template query stuff from the other
+	// Query on purpose.  This isn't a copy ctor so much as a way to
+	// ensure that "Query q(conn.query());" works correctly.
+	init(&sbuffer_);
+}
+
+
+ulonglong
+Query::affected_rows()
+{
+	return conn_->driver()->affected_rows();
+}
+
+
+int
+Query::errnum() const
+{
+	return conn_->errnum();
+}
+
+
+const char* 
+Query::error() const
+{
+	return conn_->error();
+}
+
+
+size_t
+Query::escape_string(std::string* ps, const char* original,
+		size_t length) const
+{
+	if (ps == 0) {
+		// Can't do any real work!
+		return 0;
+	}
+	else if (original == 0) {
+		// ps must point to the original data as well as to the
+		// receiving string, so get the pointer and the length from it.
+		original = ps->data();
+		length = ps->length();
+	}
+	else if (length == 0) {
+		// We got a pointer to a C++ string just for holding the result
+		// and also a C string pointing to the original, so find the
+		// length of the original.
+		length = strlen(original);
+	}
+
+	char* escaped = new char[length * 2 + 1];
+	length = escape_string(escaped, original, length);
+	ps->assign(escaped, length);
+	delete[] escaped;
+
+	return length;
+}
+
+
+size_t
+Query::escape_string(char* escaped, const char* original,
+		size_t length) const
+{
+	if (conn_ && *conn_) {
+		// Normal case
+		return conn_->driver()->escape_string(escaped, original, length);
+	}
+	else {
+		// Should only happen in test/test_manip.cpp, since it doesn't
+		// want to open a DB connection just to test the manipulators.
+		return DBDriver::escape_string_no_conn(escaped, original, length);
+	}
+}
+
+
+bool
+Query::exec(const std::string& str)
+{
+	if ((copacetic_ = conn_->driver()->execute(str.data(),
+			static_cast<unsigned long>(str.length()))) == true) {
+		if (parse_elems_.size() == 0) {
+			// Not a template query, so auto-reset
+			reset();
+		}
+		return true;
+	}
+	else if (throw_exceptions()) {
+		throw BadQuery(error(), errnum());
+	}
+	else {
+		return false;
+	}
+}
+
+
+SimpleResult
+Query::execute(SQLQueryParms& p)
+{
+	AutoFlag<> af(template_defaults.processing_);
+	return execute(str(p));
+}
+
+
+SimpleResult
+Query::execute(const SQLTypeAdapter& s)
+{
+	if ((parse_elems_.size() == 2) && !template_defaults.processing_) {
+		// We're a template query and this isn't a recursive call, so
+		// take s to be a lone parameter for the query.  We will come
+		// back in here with a completed query, but the processing_
+		// flag will be set, allowing us to avoid an infinite loop.
+		AutoFlag<> af(template_defaults.processing_);
+		return execute(SQLQueryParms() << s);
+	}
+	else {
+		// Take s to be the entire query string
+		return execute(s.data(), s.length());
+	}
+}
+
+
+SimpleResult
+Query::execute(const char* str, size_t len)
+{
+	if ((copacetic_ = conn_->driver()->execute(str, len)) == true) {
+		if (parse_elems_.size() == 0) {
+			// Not a template query, so auto-reset
+			reset();
+		}
+		return SimpleResult(conn_, insert_id(), affected_rows(), info());
+	}
+	else if (throw_exceptions()) {
+		throw BadQuery(error(), errnum());
+	}
+	else {
+		return SimpleResult();
+	}
+}
+
+
+std::string
+Query::info()
+{
+	return conn_->driver()->query_info();
+}
+
+
+ulonglong
+Query::insert_id()
+{
+	return conn_->driver()->insert_id();
+}
+
+
+bool 
+Query::more_results()
+{
+	return conn_->driver()->more_results();
+}
+
+
+Query&
+Query::operator=(const Query& rhs)
+{
+	set_exceptions(rhs.throw_exceptions());
+	template_defaults = rhs.template_defaults;
+	conn_ = rhs.conn_;
+	copacetic_ = rhs.copacetic_;
+
+	return *this;
+}
+
+Query::operator void*() const
+{
+	return *conn_ && copacetic_ ? const_cast<Query*>(this) : 0;
+}
+
+
+void
+Query::parse()
+{
+	std::string str = "";
+	char num[4];
+	std::string name;
+
+	char* s = new char[sbuffer_.str().size() + 1];
+	memcpy(s, sbuffer_.str().data(), sbuffer_.str().size()); 
+	s[sbuffer_.str().size()] = '\0';
+	const char* s0 = s;
+
+	while (*s) {
+		if (*s == '%') {
+			// Following might be a template parameter declaration...
+			s++;
+			if (*s == '%') {
+				// Doubled percent sign, so insert literal percent sign.
+				str += *s++;
+			}
+			else if (isdigit(*s)) {
+				// Number following percent sign, so it signifies a
+				// positional parameter.  First step: find position
+				// value, up to 3 digits long.
+				num[0] = *s;
+				s++;
+				if (isdigit(*s)) {
+					num[1] = *s;
+					num[2] = 0;
+					s++;
+					if (isdigit(*s)) {
+						num[2] = *s;
+						num[3] = 0;
+						s++;
+					}
+					else {
+						num[2] = 0;
+					}
+				}
+				else {
+					num[1] = 0;
+				}
+				signed char n = atoi(num);
+
+				// Look for option character following position value.
+				char option = ' ';
+				if (*s == 'q' || *s == 'Q') {
+					option = *s++;
+				}
+
+				// Is it a named parameter?
+				if (*s == ':') {
+					// Save all alphanumeric and underscore characters
+					// following colon as parameter name.
+					s++;
+					for (/* */; isalnum(*s) || *s == '_'; ++s) {
+						name += *s;
+					}
+
+					// Eat trailing colon, if it's present.
+					if (*s == ':') {
+						s++;
+					}
+
+					// Update maps that translate parameter name to
+					// number and vice versa.
+					if (n >= static_cast<short>(parsed_names_.size())) {
+						parsed_names_.insert(parsed_names_.end(),
+								static_cast<std::vector<std::string>::size_type>(
+										n + 1) - parsed_names_.size(),
+								std::string());
+					}
+					parsed_names_[n] = name;
+					parsed_nums_[name] = n;
+				}
+
+				// Finished parsing parameter; save it.
+				parse_elems_.push_back(SQLParseElement(str, option, n));
+				str = "";
+				name = "";
+			}
+			else {
+				// Insert literal percent sign, because sign didn't
+				// precede a valid parameter string; this allows users
+				// to play a little fast and loose with the rules,
+				// avoiding a double percent sign here.
+				str += '%';
+			}
+		}
+		else {
+			// Regular character, so just copy it.
+			str += *s++;
+		}
+	}
+
+	parse_elems_.push_back(SQLParseElement(str, ' ', -1));
+	delete[] s0;
+}
+
+
+SQLTypeAdapter*
+Query::pprepare(char option, SQLTypeAdapter& S, bool replace)
+{
+	if (S.is_processed()) {
+		return &S;
+	}
+
+	if (option == 'q') {
+		std::string temp(S.quote_q() ? "'" : "", S.quote_q() ? 1 : 0);
+
+		if (S.escape_q()) {
+			char *escaped = new char[S.size() * 2 + 1];
+			size_t len = conn_->driver()->escape_string(escaped,
+					S.data(), static_cast<unsigned long>(S.size()));
+			temp.append(escaped, len);
+			delete[] escaped;
+		}
+		else {
+			temp.append(S.data(), S.length());
+		}
+
+		if (S.quote_q()) temp.append("'", 1);
+
+		SQLTypeAdapter* ss = new SQLTypeAdapter(temp);
+
+		if (replace) {
+			S = *ss;
+			S.set_processed();
+			delete ss;
+			return &S;
+		}
+		else {
+			return ss;
+		}
+	}
+	else if (option == 'Q' && S.quote_q()) {
+		std::string temp("'", 1);
+		temp.append(S.data(), S.length());
+		temp.append("'", 1);
+		SQLTypeAdapter *ss = new SQLTypeAdapter(temp);
+
+		if (replace) {
+			S = *ss;
+			S.set_processed();
+			delete ss;
+			return &S;
+		}
+		else {
+			return ss;
+		}
+	}
+	else {
+		if (replace) {
+			S.set_processed();
+		}
+		return &S;
+	}
+}
+
+
+void
+Query::proc(SQLQueryParms& p)
+{
+	sbuffer_.str("");
+
+	for (std::vector<SQLParseElement>::iterator i = parse_elems_.begin();
+			i != parse_elems_.end(); ++i) {
+		MYSQLPP_QUERY_THISPTR << i->before;
+		int num = i->num;
+		if (num >= 0) {
+			SQLQueryParms* c;
+			if (size_t(num) < p.size()) {
+				c = &p;
+			}
+			else if (size_t(num) < template_defaults.size()) {
+				c = &template_defaults;
+			}
+			else {
+				*this << " ERROR";
+				throw BadParamCount(
+						"Not enough parameters to fill the template.");
+			}
+
+			SQLTypeAdapter& param = (*c)[num];
+			SQLTypeAdapter* ss = pprepare(i->option, param, c->bound());
+			MYSQLPP_QUERY_THISPTR << *ss;
+			if (ss != &param) {
+				// pprepare() returned a new string object instead of
+				// updating param in place, so we need to delete it.
+				delete ss;
+			}
+		}
+	}
+}
+
+
+void
+Query::reset()
+{
+	seekp(0);
+	clear();
+	sbuffer_.str("");
+
+	parse_elems_.clear();
+	template_defaults.clear();
+}
+
+
+StoreQueryResult
+Query::store(SQLQueryParms& p)
+{
+	AutoFlag<> af(template_defaults.processing_);
+	return store(str(p));
+}
+
+
+StoreQueryResult 
+Query::store(const SQLTypeAdapter& s)
+{
+	if ((parse_elems_.size() == 2) && !template_defaults.processing_) {
+		// We're a template query and this isn't a recursive call, so
+		// take s to be a lone parameter for the query.  We will come
+		// back in here with a completed query, but the processing_
+		// flag will be set, allowing us to avoid an infinite loop.
+		AutoFlag<> af(template_defaults.processing_);
+		return store(SQLQueryParms() << s);
+	}
+	else {
+		// Take s to be the entire query string
+		return store(s.data(), s.length());
+	}
+}
+
+
+StoreQueryResult
+Query::store(const char* str, size_t len)
+{
+	MYSQL_RES* res = 0;
+	if ((copacetic_ = conn_->driver()->execute(str, len)) == true) {
+		res = conn_->driver()->store_result();
+	}
+
+	if (res) {
+		if (parse_elems_.size() == 0) {
+			// Not a template query, so auto-reset
+			reset();
+		}
+		return StoreQueryResult(res, conn_->driver(), throw_exceptions());
+	}
+	else {
+		// Either result set is empty, or there was a problem executing
+		// the query or storing its results.  Since it's not an error to
+		// use store() with queries that never return results (INSERT,
+		// DELETE, CREATE, ALTER...) we need to figure out which case
+		// this is.  (You might use store() instead of execute() for
+		// such queries when the query strings come from "outside".)
+		if (copacetic_ = (conn_->errnum() == 0)) {
+			if (parse_elems_.size() == 0) {
+				// Not a template query, so auto-reset
+				reset();
+			}
+			return StoreQueryResult();
+		}
+		else if (throw_exceptions()) {
+			throw BadQuery(error(), errnum());
+		}
+		else {
+			return StoreQueryResult();
+		}
+	}
+}
+
+
+StoreQueryResult
+Query::store_next()
+{
+#if MYSQL_VERSION_ID > 41000		// only in MySQL v4.1 +
+	DBDriver::nr_code rc = conn_->driver()->next_result();
+	if (rc == DBDriver::nr_more_results) {
+		// There are more results, so return next result set.
+		MYSQL_RES* res = conn_->driver()->store_result();
+		if (res) {
+			return StoreQueryResult(res, conn_->driver(),
+					throw_exceptions());
+		} 
+		else {
+			// Result set is null, but throw an exception only i it is
+			// null because of some error.  If not, it's just an empty
+			// result set, which is harmless.  We return an empty result
+			// set if exceptions are disabled, as well.
+			if (conn_->errnum() && throw_exceptions()) {
+				throw BadQuery(error(), errnum());
+			} 
+			else {
+				return StoreQueryResult();
+			}
+		}
+	}
+	else if (throw_exceptions()) {
+        if (rc == DBDriver::nr_error) {
+            throw BadQuery(error(), errnum());
+        }
+		else if (conn_->errnum()) {
+			throw BadQuery(error(), errnum());
+        }
+		else {
+			return StoreQueryResult();	// normal end-of-result-sets case
+		}
+    }
+    else {
+        return StoreQueryResult();
+	}
+#else
+	return store();
+#endif // MySQL v4.1+
+}
+
+
+std::string
+Query::str(SQLQueryParms& p)
+{
+	if (!parse_elems_.empty()) {
+		proc(p);
+	}
+
+	return sbuffer_.str();
+}
+
+
+UseQueryResult
+Query::use(SQLQueryParms& p)
+{
+	AutoFlag<> af(template_defaults.processing_);
+	return use(str(p));
+}
+
+
+UseQueryResult
+Query::use(const SQLTypeAdapter& s)
+{
+	if ((parse_elems_.size() == 2) && !template_defaults.processing_) {
+		// We're a template query and this isn't a recursive call, so
+		// take s to be a lone parameter for the query.  We will come
+		// back in here with a completed query, but the processing_
+		// flag will be set, allowing us to avoid an infinite loop.
+		AutoFlag<> af(template_defaults.processing_);
+		return use(SQLQueryParms() << s);
+	}
+	else {
+		// Take s to be the entire query string
+		return use(s.data(), s.length());
+	}
+}
+
+
+UseQueryResult
+Query::use(const char* str, size_t len)
+{
+	MYSQL_RES* res = 0;
+	if ((copacetic_ = conn_->driver()->execute(str, len)) == true) {
+		res = conn_->driver()->use_result();
+	}
+
+	if (res) {
+		if (parse_elems_.size() == 0) {
+			// Not a template query, so auto-reset
+			reset();
+		}
+		return UseQueryResult(res, conn_->driver(), throw_exceptions());
+	}
+	else {
+		// See comments in store() above for why we distinguish between
+		// empty result sets and actual error returns here.
+		if (copacetic_ = (conn_->errnum() == 0)) {
+			if (parse_elems_.size() == 0) {
+				// Not a template query, so auto-reset
+				reset();
+			}
+			return UseQueryResult();
+		}
+		else if (throw_exceptions()) {
+			throw BadQuery(error(), errnum());
+		}
+		else {
+			return UseQueryResult();
+		}
+	}
+}
+
+
+} // end namespace mysqlpp
+

ADDED   lib/query.h
Index: lib/query.h
==================================================================
--- /dev/null
+++ lib/query.h
@@ -0,0 +1,1080 @@
+/// \file query.h
+/// \brief Defines a class for building and executing SQL queries.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_QUERY_H)
+#define MYSQLPP_QUERY_H
+
+#include "common.h"
+
+#include "noexceptions.h"
+#include "qparms.h"
+#include "querydef.h"
+#include "result.h"
+#include "row.h"
+#include "stadapter.h"
+
+#include <deque>
+#include <iomanip>
+#include <list>
+#include <map>
+#include <set>
+#include <vector>
+
+#ifdef HAVE_EXT_SLIST
+#  include <ext/slist>
+#else
+#  if defined(HAVE_STD_SLIST) || defined(HAVE_GLOBAL_SLIST)
+#      include <slist>
+#  endif
+#endif
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class MYSQLPP_EXPORT Connection;
+#endif
+
+/// \brief A class for building and executing SQL queries.
+///
+/// One does not generally create Query objects directly. Instead, call
+/// mysqlpp::Connection::query() to get one tied to that connection.
+///
+/// There are several ways to build and execute SQL queries with this
+/// class.
+///
+/// The way most like other database libraries is to pass a SQL
+/// statement in either the form of a C or C++ string to one of the
+/// \link mysqlpp::Query::execute() exec*(), \endlink
+/// \link mysqlpp::Query::store() store*(), \endlink or use() methods.
+/// The query is executed immediately, and any results returned.
+///
+/// For more complicated queries, it's often more convenient to build up
+/// the query string over several C++ statements using Query's stream
+/// interface. It works like any other C++ stream (\c std::cout,
+/// \c std::ostringstream, etc.) in that you can just insert things
+/// into the stream, building the query up piece by piece. When the
+/// query string is complete, you  call the overloaded version of
+/// \link mysqlpp::Query::execute() exec*(), \endlink
+/// \link mysqlpp::Query::store() store*(), \endlink or
+/// \link mysqlpp::Query::use() use() \endlink takes no parameters,
+/// which executes the built query and returns any results.
+///
+/// If you are using the library's Specialized SQL Structures feature,
+/// Query has several special functions for generating common SQL
+/// queries from those structures. For instance, it offers the
+/// \link mysqlpp::Query::insert() insert() \endlink method, which
+/// builds an INSERT query to add the contents of the SSQLS to the
+/// database. As with the stream interface, these methods only build
+/// the query string; call one of the parameterless methods mentioned
+/// previously to actually execute the query.
+///
+/// Finally, you can build "template queries". This is something like
+/// C's \c printf() function, in that you insert a specially-formatted
+/// query string into the object which contains placeholders for data.
+/// You call the parse() method to tell the Query object that the query
+/// string contains placeholders. Having done that, you call one of the
+/// the many
+/// \link mysqlpp::Query::execute(const SQLTypeAdapter&) exec*(), \endlink
+/// \link mysqlpp::Query::store(const SQLTypeAdapter&) store*(), \endlink
+/// or \link mysqlpp::Query::use(const SQLTypeAdapter&) use() \endlink
+/// overloads that take SQLTypeAdapter objects.  There are 25 of each by
+/// default, differing only in the number of STA objects they take.
+/// (See \c lib/querydef.pl if you need to change the limit, or 
+/// \c examples/tquery2.cpp for a way around it that doesn't require 
+/// changing the library.)  Only the version taking a single STA object
+/// is documented below, as to document all of them would just be
+/// repetitive.  For each Query method that takes a single STA object,
+/// there's a good chance there's a set of undocumented overloads that
+/// take more of them for the purpose of filling out a template query.
+///
+/// See the user manual for more details about these options.
+
+class MYSQLPP_EXPORT Query :
+        public std::ostream,
+		public OptionalExceptions
+{
+public:
+	/// \brief Create a new query object attached to a connection.
+	///
+	/// This is the constructor used by mysqlpp::Connection::query().
+	///
+	/// \param c connection the finished query should be sent out on
+	/// \param te if true, throw exceptions on errors
+	/// \param qstr an optional initial query string
+	Query(Connection* c, bool te = true, const char* qstr = 0);
+
+	/// \brief Create a new query object as a copy of another.
+	///
+	/// This is \b not a traditional copy ctor!  Its only purpose is to
+	/// make it possible to assign the return of Connection::query()
+	/// to an empty Query object.  In particular, the stream buffer and
+	/// template query stuff will be empty in the copy, regardless of
+	/// what values they have in the original.
+	Query(const Query& q);
+
+	/// \brief Return the number of rows affected by the last query
+	ulonglong affected_rows();
+
+	/// \brief Return a SQL-escaped version of a character buffer
+	///
+	/// \param ps pointer to C++ string to hold escaped version; if
+	/// original is 0, also holds the original data to be escaped
+	/// \param original if given, pointer to the character buffer to
+	/// escape instead of contents of *ps
+	/// \param length if both this and original are given, number of
+	/// characters to escape instead of ps->length()
+	///
+	/// \retval number of characters placed in *ps
+	///
+	/// This method has three basic operation modes:
+	///
+	/// - Pass just a pointer to a C++ string containing the original
+	///   data to escape, plus act as receptacle for escaped version
+	/// - Pass a pointer to a C++ string to receive escaped string plus
+	///   a pointer to a C string to be escaped
+	/// - Pass nonzero for all parameters, taking original to be a
+	///   pointer to an array of char with given length; does not treat
+	///   null characters as special
+	///
+	/// There's a degenerate fourth mode, where ps is zero: simply
+	/// returns 0, because there is nowhere to store the result.
+	///
+	/// Note that if original is 0, we always ignore the length
+	/// parameter even if it is nonzero.  Length always comes from
+	/// ps->length() in this case.
+	///
+	/// ps is a pointer because if it were a reference, the other
+	/// overload would be impossible to call: the compiler would
+	/// complain that the two overloads are ambiguous because
+	/// std::string has a char* conversion ctor. A nice bonus is that
+	/// pointer syntax makes it clearer that the first parameter is an
+	/// "out" parameter.
+	///
+	/// \see comments for escape_string(char*, const char*, size_t)
+	/// for further details.
+	size_t escape_string(std::string* ps, const char* original = 0,
+			size_t length = 0) const;
+
+	/// \brief Return a SQL-escaped version of the given character
+	/// buffer
+	///
+	/// \param escaped character buffer to hold escaped version; must
+	/// point to at least (length * 2 + 1) bytes
+	/// \param original pointer to the character buffer to escape
+	/// \param length number of characters to escape
+	///
+	/// \retval number of characters placed in escaped
+	///
+	/// This is part of Query because proper SQL escaping takes the
+	/// database's current character set into account, which requires
+	/// access to the Connection object the query will go out on.  Also,
+	/// this function is very important to MySQL++'s Query stream
+	/// manipulator mechanism, so it's more convenient for this method
+	/// to live in Query rather than Connection.
+	size_t escape_string(char* escaped, const char* original,
+			size_t length) const;
+
+	/// \brief Get the last error number that was set.
+	///
+	/// This just delegates to Connection::errnum().  Query has nothing
+	/// extra to say, so use either, as makes sense in your program.
+	int errnum() const;
+
+	/// \brief Get the last error message that was set.
+	///
+	/// This just delegates to Connection::error().  Query has nothing
+	/// extra to say, so use either, as makes sense in your program.
+	const char* error() const;
+
+	/// \brief Returns information about the most recently executed
+	/// query.
+	std::string info();
+
+	/// \brief Get ID generated for an AUTO_INCREMENT column in the
+	/// previous INSERT query.
+	///
+	/// \retval 0 if the previous query did not generate an ID.  Use
+	/// the SQL function LAST_INSERT_ID() if you need the last ID
+	/// generated by any query, not just the previous one.
+	ulonglong insert_id();
+
+	/// \brief Assign another query's state to this object
+	///
+	/// The same caveats apply to this operator as apply to the copy
+	/// ctor.
+	Query& operator=(const Query& rhs);
+
+	/// \brief Test whether the object has experienced an error condition
+	///
+	/// Allows for code constructs like this:
+	///
+	/// \code
+	///	Query q = conn.query();
+	///	.... use query object
+	///	if (q) {
+	///	    ... no problems in using query object
+	///	}
+	///	else {
+	///	    ... an error has occurred
+	///	}
+	/// \endcode
+	///
+	/// This method returns false if either the Query object or its
+	/// associated Connection object has seen an error condition since
+	/// the last operation.
+	operator void*() const;
+
+	/// \brief Treat the contents of the query string as a template
+	/// query.
+	///
+	/// This method sets up the internal structures used by all of the
+	/// other members that accept template query parameters.  See the
+	/// "Template Queries" chapter in the user manual for more
+	/// information.
+	void parse();
+
+	/// \brief Reset the query object so that it can be reused.
+	///
+	/// As of v3.0, Query objects auto-reset upon query execution unless
+	/// you've set it up for making template queries.  (It can't auto-reset
+	/// in that situation, because it would forget the template info.)
+	/// Therefore, the only time you must call this is if you have a Query
+	/// object set up for making template queries, then want to build
+	/// queries using one of the other methods.  (Static strings, SSQLS,
+	/// or the stream interface.)
+	void reset();
+
+	/// \brief Get built query as a C++ string
+	std::string str() { return str(template_defaults); }
+
+	/// \brief Get built query as a C++ string with template query
+	/// parameter substitution.
+	///
+	/// \param arg0 the value to substitute for the first template query
+	/// parameter; because SQLTypeAdapter implicitly converts from many
+	/// different data types, this method is very flexible in what it
+	/// accepts as a parameter.  You shouldn't have to use the
+	/// SQLTypeAdapter data type directly in your code.
+	///
+	/// There many more overloads of this type (25 total, by default;
+	/// see \c lib/querydef.pl), each taking one more SQLTypeAdapter object
+	/// than the previous one.  See the template query overview above
+	/// for more about this topic.
+	std::string str(const SQLTypeAdapter& arg0)
+			{ return str(SQLQueryParms() << arg0); }
+
+	/// \brief Get built query as a null-terminated C++ string
+	///
+	/// \param p template query parameters to use, overriding the ones
+	/// this object holds, if any
+	std::string str(SQLQueryParms& p);
+
+	/// \brief Execute a built-up query
+	///
+	/// Same as exec(), except that it uses the query string built up
+	/// within the query object already instead of accepting a query
+	/// string from the caller.
+	///
+	/// \return true if query was executed successfully
+	///
+	/// \sa exec(const std::string& str), execute(), store(),
+	/// storein(), and use()
+	bool exec() { return exec(str(template_defaults)); }
+
+	/// \brief Execute a query
+	///
+	/// Same as execute(), except that it only returns a flag indicating
+	/// whether the query succeeded or not.  It is basically a thin
+	/// wrapper around the C API function \c mysql_real_query().
+	///
+	/// \param str the query to execute
+	///
+	/// \return true if query was executed successfully
+	///
+	/// \sa execute(), store(), storein(), and use()
+	bool exec(const std::string& str);
+
+	/// \brief Execute built-up query
+	///
+	/// Use one of the execute() overloads if you don't expect the
+	/// server to return a result set. For instance, a DELETE query.
+	/// The returned SimpleResult object contains status information from
+	/// the server, such as whether the query succeeded, and if so how
+	/// many rows were affected.
+	///
+	/// This overloaded version of execute() simply executes the query
+	/// that you have built up in the object in some way. (For instance,
+	/// via the insert() method, or by using the object's stream
+	/// interface.)
+	///
+	/// \return SimpleResult status information about the query
+	///
+	/// \sa exec(), store(), storein(), and use()
+	SimpleResult execute() { return execute(str(template_defaults)); }
+
+	/// \brief Execute template query using given parameters.
+    ///
+    /// This method should only be used by code that doesn't know,
+    /// at compile time, how many parameters it will have.  This is
+    /// useful within the library, and also for code that builds
+    /// template queries dynamically, at run time.
+	///
+	/// \param p parameters to use in the template query.
+	SimpleResult execute(SQLQueryParms& p);
+
+	/// \brief Execute a query that returns no rows
+	///
+	/// \param str if this object is set up as a template query, this is
+	/// the value to substitute for the first template query parameter;
+	/// else, it is the SQL query string to execute
+	///
+	/// Because SQLTypeAdapter can be initialized from either a C string
+	/// or a C++ string, this overload accepts query strings in either
+	/// form.  Beware, SQLTypeAdapter also accepts many other data types
+	/// (this is its \e raison \e d'etre), so it will let you write code
+	/// that compiles but results in bogus SQL queries.
+	///
+	/// To support template queries, there many more overloads of this
+	/// type (25 total, by default; see \c lib/querydef.pl), each taking
+	/// one more SQLTypeAdapter object than the previous one.  See the
+	/// template query overview above for more about this topic.
+	SimpleResult execute(const SQLTypeAdapter& str);
+
+	/// \brief Execute query in a known-length string of characters.
+	/// This can include null characters.
+	///
+	/// Executes the query immediately, and returns the results.
+	SimpleResult execute(const char* str, size_t len);
+
+	/// \brief Execute a query that can return rows, with access to
+	/// the rows in sequence
+	/// 
+	/// Use one of the use() overloads if memory efficiency is
+	/// important.  They return an object that can walk through
+	/// the result records one by one, without fetching the entire
+	/// result set from the server.  This is superior to store()
+	/// when there are a large number of results; store() would have to
+	/// allocate a large block of memory to hold all those records,
+	/// which could cause problems.
+	///
+	/// A potential downside of this method is that MySQL database
+	/// resources are tied up until the result set is completely
+	/// consumed.  Do your best to walk through the result set as
+	/// expeditiously as possible.
+	///
+	/// The name of this method comes from the MySQL C API function
+	/// that initiates the retrieval process, \c mysql_use_result().
+	/// This method is implemented in terms of that function.
+	///
+	/// This function has the same set of overloads as execute().
+	///
+	/// \return UseQueryResult object that can walk through result set serially
+	///
+	/// \sa exec(), execute(), store() and storein()
+	UseQueryResult use() { return use(str(template_defaults)); }
+
+	/// \brief Execute a template query that can return rows, with
+	/// access to the rows in sequence
+    ///
+    /// This method should only be used by code that doesn't know,
+    /// at compile time, how many parameters it will have.  This is
+    /// useful within the library, and also for code that builds
+    /// template queries dynamically, at run time.
+	///
+	/// \param p parameters to use in the template query.
+	UseQueryResult use(SQLQueryParms& p);
+
+	/// \brief Execute a query that can return rows, with access to
+	/// the rows in sequence
+	///
+	/// \param str if this object is set up as a template query, this is
+	/// the value to substitute for the first template query parameter;
+	/// else, it is the SQL query string to execute
+	///
+	/// Because SQLTypeAdapter can be initialized from either a C string
+	/// or a C++ string, this overload accepts query strings in either
+	/// form.  Beware, SQLTypeAdapter also accepts many other data types
+	/// (this is its \e raison \e d'etre), so it will let you write code
+	/// that compiles but results in bogus SQL queries.
+	///
+	/// To support template queries, there many more overloads of this
+	/// type (25 total, by default; see \c lib/querydef.pl), each taking
+	/// one more SQLTypeAdapter object than the previous one.  See the
+	/// template query overview above for more about this topic.
+	UseQueryResult use(const SQLTypeAdapter& str);
+
+	/// \brief Execute a query that can return rows, with access to
+	/// the rows in sequence
+	///
+	/// This overload is for situations where you have the query in a
+	/// C string and have its length already.  If you want to execute
+	/// a query in a null-terminated C string or have the query string
+	/// in some other form, you probably want to call
+	/// use(const SQLTypeAdapter&) instead.  SQLTypeAdapter converts
+	/// from plain C strings and other useful data types implicitly.
+	UseQueryResult use(const char* str, size_t len);
+
+	/// \brief Execute a query that can return a result set
+	///
+	/// Use one of the store() overloads to execute a query and retrieve
+	/// the entire result set into memory.  This is useful if you
+	/// actually need all of the records at once, but if not, consider
+	/// using one of the use() methods instead, which returns the results
+	/// one at a time, so they don't allocate as much memory as store().
+	///
+	/// You must use store(), storein() or use() for \c SELECT, \c SHOW,
+	/// \c DESCRIBE and \c EXPLAIN queries.  You can use these functions
+	/// with other query types, but since they don't return a result
+	/// set, exec() and execute() are more efficient.
+	///
+	/// The name of this method comes from the MySQL C API function it
+	/// is implemented in terms of, \c mysql_store_result().
+	///
+	/// This function has the same set of overloads as execute().
+	///
+	/// \return StoreQueryResult object containing entire result set
+	///
+	/// \sa exec(), execute(), storein(), and use()
+	StoreQueryResult store() { return store(str(template_defaults)); }
+
+	/// \brief Store results from a template query using given parameters.
+    ///
+    /// This method should only be used by code that doesn't know,
+    /// at compile time, how many parameters it will have.  This is
+    /// useful within the library, and also for code that builds
+    /// template queries dynamically, at run time.
+	///
+	/// \param p parameters to use in the template query.
+	StoreQueryResult store(SQLQueryParms& p);
+
+	/// \brief Execute a query that can return rows, returning all
+	/// of the rows in a random-access container
+	///
+	/// \param str if this object is set up as a template query, this is
+	/// the value to substitute for the first template query parameter;
+	/// else, it is the SQL query string to execute
+	///
+	/// Because SQLTypeAdapter can be initialized from either a C string
+	/// or a C++ string, this overload accepts query strings in either
+	/// form.  Beware, SQLTypeAdapter also accepts many other data types
+	/// (this is its \e raison \e d'etre), so it will let you write code
+	/// that compiles but results in bogus SQL queries.
+	///
+	/// To support template queries, there many more overloads of this
+	/// type (25 total, by default; see \c lib/querydef.pl), each taking
+	/// one more SQLTypeAdapter object than the previous one.  See the
+	/// template query overview above for more about this topic.
+	StoreQueryResult store(const SQLTypeAdapter& str);
+
+	/// \brief Execute a query that can return rows, returning all
+	/// of the rows in a random-access container
+	///
+	/// This overload is for situations where you have the query in a
+	/// C string and have its length already.  If you want to execute
+	/// a query in a null-terminated C string or have the query string
+	/// in some other form, you probably want to call
+	/// store(const SQLTypeAdapter&) instead.  SQLTypeAdapter converts
+	/// from plain C strings and other useful data types implicitly.
+	StoreQueryResult store(const char* str, size_t len);
+
+	/// \brief Execute a query, and call a functor for each returned row
+	///
+	/// This method wraps a use() query, calling the given functor for
+	/// every returned row.  It is analogous to STL's for_each()
+	/// algorithm, but instead of iterating over some range within a
+	/// container, it iterates over a result set produced by a query.
+	///
+	/// \param query the query string
+	/// \param fn the functor called for each row
+	/// \return a copy of the passed functor
+	template <typename Function>
+	Function for_each(const SQLTypeAdapter& query, Function fn)
+	{	
+		mysqlpp::UseQueryResult res = use(query);
+		if (res) {
+			mysqlpp::NoExceptions ne(res);
+			while (mysqlpp::Row row = res.fetch_row()) {
+				fn(row);
+			}
+		}
+
+		return fn;
+	}
+
+	/// \brief Execute the query, and call a functor for each returned row
+	///
+	/// Just like for_each(const SQLTypeAdapter&, Function), but it uses
+	/// the query string held by the Query object already
+	///
+	/// \param fn the functor called for each row
+	/// \return a copy of the passed functor
+	template <typename Function>
+	Function for_each(Function fn)
+	{	
+		mysqlpp::UseQueryResult res = use();
+		if (res) {
+			mysqlpp::NoExceptions ne(res);
+			while (mysqlpp::Row row = res.fetch_row()) {
+				fn(row);
+			}
+		}
+
+		return fn;
+	}
+
+	/// \brief Run a functor for every row in a table
+	///
+	/// Just like for_each(Function), except that it builds a
+	/// "select * from TABLE" query using the SQL table name from
+	/// the SSQLS instance you pass.
+	///
+	/// \param ssqls the SSQLS instance to get a table name from
+	/// \param fn the functor called for each row
+	///
+	/// \return a copy of the passed functor
+	template <class SSQLS, typename Function>
+	Function for_each(const SSQLS& ssqls, Function fn)
+	{	
+		std::string query("select * from ");
+		query += ssqls.table();
+		mysqlpp::UseQueryResult res = use(query);
+		if (res) {
+			mysqlpp::NoExceptions ne(res);
+			while (mysqlpp::Row row = res.fetch_row()) {
+				fn(row);
+			}
+		}
+
+		return fn;
+	}
+
+	/// \brief Execute a query, conditionally storing each row in a
+	/// container
+	///
+	/// This method wraps a use() query, calling the given functor for
+	/// every returned row, and storing the results in the given
+	/// sequence container if the functor returns true.
+	///
+	/// This is analogous to the STL copy_if() algorithm, except that
+	/// the source rows come from a database query instead of another
+	/// container.  (copy_if() isn't a standard STL algorithm, but only
+	/// due to an oversight by the standardization committee.)  This
+	/// fact may help you to remember the order of the parameters: the
+	/// container is the destination, the query is the source, and the
+	/// functor is the predicate; it's just like an STL algorithm.
+	///
+	/// \param con the destination container; needs a push_back() method
+	/// \param query the query string
+	/// \param fn the functor called for each row
+	/// \return a copy of the passed functor
+	template <class Sequence, typename Function>
+	Function store_if(Sequence& con, const SQLTypeAdapter& query, Function fn)
+	{	
+		mysqlpp::UseQueryResult res = use(query);
+		if (res) {
+			mysqlpp::NoExceptions ne(res);
+			while (mysqlpp::Row row = res.fetch_row()) {
+				if (fn(row)) {
+					con.push_back(row);
+				}
+			}
+		}
+
+		return fn;
+	}
+
+	/// \brief Pulls every row in a table, conditionally storing each
+	/// one in a container
+	///
+	/// Just like store_if(Sequence&, const SQLTypeAdapter&, Function), but
+	/// it uses the SSQLS instance to construct a "select * from TABLE"
+	/// query, using the table name field in the SSQLS.
+	///
+	/// \param con the destination container; needs a push_back() method
+	/// \param ssqls the SSQLS instance to get a table name from
+	/// \param fn the functor called for each row
+	/// \return a copy of the passed functor
+	template <class Sequence, class SSQLS, typename Function>
+	Function store_if(Sequence& con, const SSQLS& ssqls, Function fn)
+	{	
+		std::string query("select * from ");
+		query += ssqls.table();
+		mysqlpp::UseQueryResult res = use(query);
+		if (res) {
+			mysqlpp::NoExceptions ne(res);
+			while (mysqlpp::Row row = res.fetch_row()) {
+				if (fn(row)) {
+					con.push_back(row);
+				}
+			}
+		}
+
+		return fn;
+	}
+
+	/// \brief Execute the query, conditionally storing each row in a
+	/// container
+	///
+	/// Just like store_if(Sequence&, const SQLTypeAdapter&, Function), but
+	/// it uses the query string held by the Query object already
+	///
+	/// \param con the destination container; needs a push_back() method
+	/// \param fn the functor called for each row
+	/// \return a copy of the passed functor
+	template <class Sequence, typename Function>
+	Function store_if(Sequence& con, Function fn)
+	{	
+		mysqlpp::UseQueryResult res = use();
+		if (res) {
+			mysqlpp::NoExceptions ne(res);
+			while (mysqlpp::Row row = res.fetch_row()) {
+				if (fn(row)) {
+					con.push_back(row);
+				}
+			}
+		}
+
+		return fn;
+	}
+
+	/// \brief Return next result set, when processing a multi-query
+	///
+	/// There are two cases where you'd use this function instead of
+	/// the regular store() functions.
+	/// 
+	/// First, when handling the result of executing multiple queries
+	/// at once.  (See <a
+	/// href="http://dev.mysql.com/doc/mysql/en/c-api-multiple-queries.html">this
+	/// page</a> in the MySQL documentation for details.) 
+	///
+	/// Second, when calling a stored procedure, MySQL can return the
+	/// result as a set of results.
+	///
+	/// In either case, you must consume all results before making
+	/// another MySQL query, even if you don't care about the remaining
+	/// results or result sets.
+	///
+	/// As the MySQL documentation points out, you must set the
+	/// MYSQL_OPTION_MULTI_STATEMENTS_ON flag on the connection in order
+	/// to use this feature.  See Connection::set_option().
+	///
+	/// Multi-queries only exist in MySQL v4.1 and higher.  Therefore,
+	/// this function just wraps store() when built against older API
+	/// libraries.
+	///
+	/// \return StoreQueryResult object containing the next result set.
+	StoreQueryResult store_next();
+
+	/// \brief Return whether more results are waiting for a multi-query
+	/// or stored procedure response.
+	///
+	/// If this function returns true, you must call store_next() to
+	/// fetch the next result set before you can execute more queries.
+	///
+	/// Wraps mysql_more_results() in the MySQL C API.  That function
+	/// only exists in MySQL v4.1 and higher.  Therefore, this function
+	/// always returns false when built against older API libraries.
+	///
+	/// \return true if another result set exists
+	bool more_results();
+
+	/// \brief Execute a query, storing the result set in an STL
+	/// sequence container.
+	///
+	/// This function works much like store() from the caller's
+	/// perspective, because it returns the entire result set at once.
+	/// It's actually implemented in terms of use(), however, so that
+	/// memory for the result set doesn't need to be allocated twice.
+	///
+	/// There are many overloads for this function, pretty much the same
+	/// as for execute(), except that there is a Container parameter at
+	/// the front of the list.  So, you can pass a container and a query
+	/// string, or a container and template query parameters.
+	///
+	/// \param con any STL sequence container, such as \c std::vector
+	///
+	/// \sa exec(), execute(), store(), and use()
+	template <class Sequence>
+	void storein_sequence(Sequence& con)
+	{
+		storein_sequence(con, str(template_defaults));
+	}
+
+	/// \brief Executes a query, storing the result rows in an STL
+	/// sequence container.
+	///
+	/// \param con the container to store the results in
+	///
+	/// \param s if Query is set up as a template query, this is the value
+	/// to substitute for the first template query parameter; else, the
+	/// SQL query string
+	///
+	/// There many more overloads of this type (25 total, by default;
+	/// see \c lib/querydef.pl), each taking one more SQLTypeAdapter object
+	/// than the previous one.  See the template query overview above
+	/// for more about this topic.
+	template <class Sequence>
+	void storein_sequence(Sequence& con, const SQLTypeAdapter& s)
+	{
+		UseQueryResult result = use(s);
+		while (1) {
+			MYSQL_ROW d = result.fetch_raw_row();
+			if (!d)
+				break;
+			Row row(d, &result, result.fetch_lengths(), true);
+			if (!row)
+				break;
+			con.push_back(typename Sequence::value_type(row));
+		}
+	}
+
+	/// \brief Execute template query using given parameters, storing
+    /// the results in a sequence type container.
+    ///
+    /// This method should only be used by code that doesn't know,
+    /// at compile time, how many parameters it will have.  This is
+    /// useful within the library, and also for code that builds
+    /// template queries dynamically, at run time.
+	///
+	/// \param con container that will receive the results
+	/// \param p parameters to use in the template query.
+    template <class Seq>
+    void storein_sequence(Seq& con, SQLQueryParms& p)
+    {
+        storein_sequence(con, str(p));
+    }
+
+	/// \brief Execute a query, storing the result set in an STL
+	/// associative container.
+	///
+	/// The same thing as storein_sequence(), except that it's used with
+	/// associative STL containers, such as \c std::set.  Other than
+	/// that detail, that method's comments apply equally well to this
+	/// one.
+	template <class Set>
+	void storein_set(Set& con)
+	{
+		storein_set(con, str(template_defaults));
+	}
+
+	/// \brief Executes a query, storing the result rows in an STL
+	/// set-associative container.
+	///
+	/// \param con the container to store the results in
+	///
+	/// \param s if Query is set up as a template query, this is the value
+	/// to substitute for the first template query parameter; else, the
+	/// SQL query string
+	///
+	/// There many more overloads of this type (25 total, by default;
+	/// see \c lib/querydef.pl), each taking one more SQLTypeAdapter object
+	/// than the previous one.  See the template query overview above
+	/// for more about this topic.
+	template <class Set>
+	void storein_set(Set& con, const SQLTypeAdapter& s)
+	{
+		UseQueryResult result = use(s);
+		while (1) {
+			MYSQL_ROW d = result.fetch_raw_row();
+			if (!d)
+				return;
+			Row row(d, &result, result.fetch_lengths(), true);
+			if (!row)
+				break;
+			con.insert(typename Set::value_type(row));
+		}
+	}
+
+	/// \brief Execute template query using given parameters, storing
+    /// the results in a set type container.
+    ///
+    /// This method should only be used by code that doesn't know,
+    /// at compile time, how many parameters it will have.  This is
+    /// useful within the library, and also for code that builds
+    /// template queries dynamically, at run time.
+	///
+	/// \param con container that will receive the results
+	/// \param p parameters to use in the template query.
+    template <class Set>
+    void storein_set(Set& con, SQLQueryParms& p)
+    {
+        storein_set(con, str(p));
+    }
+
+	/// \brief Execute a query, and store the entire result set
+	/// in an STL container.
+	///
+	/// This is a set of specialized template functions that call either
+	/// storein_sequence() or storein_set(), depending on the type of
+	/// container you pass it. It understands \c std::vector, \c deque,
+	/// \c list, \c slist (a common C++ library extension), \c set,
+	/// and \c multiset.
+	///
+	/// Like the functions it wraps, this is actually an overloaded set
+	/// of functions. See the other functions' documentation for details.
+	///
+	/// Use this function if you think you might someday switch your
+	/// program from using a set-associative container to a sequence
+	/// container for storing result sets, or vice versa.
+	///
+	/// See exec(), execute(), store(), and use() for alternative
+	/// query execution mechanisms.
+	template <class Container>
+	void storein(Container& con)
+	{
+		storein(con, str(template_defaults));
+	}
+
+	/// \brief Specialization of storein_sequence() for \c std::vector
+	template <class T>
+	void storein(std::vector<T>& con, const SQLTypeAdapter& s)
+	{
+		storein_sequence(con, s);
+	}
+
+	/// \brief Specialization of storein_sequence() for \c std::deque
+	template <class T>
+	void storein(std::deque<T>& con, const SQLTypeAdapter& s)
+	{
+		storein_sequence(con, s);
+	}
+
+	/// \brief Specialization of storein_sequence() for \c std::list
+	template <class T>
+	void storein(std::list<T>& con, const SQLTypeAdapter& s)
+	{
+		storein_sequence(con, s);
+	}
+
+#if defined(HAVE_EXT_SLIST)
+	/// \brief Specialization of storein_sequence() for g++ STL
+	/// extension \c slist
+	template <class T>
+	void storein(__gnu_cxx::slist<T>& con, const SQLTypeAdapter& s)
+	{
+		storein_sequence(con, s);
+	}
+#elif defined(HAVE_GLOBAL_SLIST)
+	/// \brief Specialization of storein_sequence() for STL
+	/// extension \c slist
+	///
+	/// This is primarily for older versions of g++, which put \c slist
+	/// in the global namespace.  This is a common language extension,
+	/// so this may also work for other compilers.
+	template <class T>
+	void storein(slist<T>& con, const SQLTypeAdapter& s)
+	{
+		storein_sequence(con, s);
+	}
+#elif defined(HAVE_STD_SLIST)
+	/// \brief Specialization of storein_sequence() for STL
+	/// extension \c slist
+	///
+	/// This is for those benighted compilers that include an \c slist
+	/// implementation, but erroneously put it in the \c std namespace!
+	template <class T>
+	void storein(std::slist<T>& con, const SQLTypeAdapter& s)
+	{
+		storein_sequence(con, s);
+	}
+#endif
+
+	/// \brief Specialization of storein_set() for \c std::set
+	template <class T>
+	void storein(std::set<T>& con, const SQLTypeAdapter& s)
+	{
+		storein_set(con, s);
+	}
+
+	/// \brief Specialization of storein_set() for \c std::multiset
+	template <class T>
+	void storein(std::multiset<T>& con, const SQLTypeAdapter& s)
+	{
+		storein_set(con, s);
+	}
+
+	/// \brief Replace an existing row's data with new data.
+	///
+	/// This function builds an UPDATE SQL query using the new row data
+	/// for the SET clause, and the old row data for the WHERE clause.
+	/// One uses it with MySQL++'s Specialized SQL Structures mechanism.
+	///
+	/// \param o old row
+	/// \param n new row
+	///
+	/// \sa insert(), replace()
+	template <class T>
+	Query& update(const T& o, const T& n)
+	{
+		reset();
+
+		// Cast required for VC++ 2003 due to error in overloaded operator
+		// lookup logic.  For an explanation of the problem, see:
+		// http://groups-beta.google.com/group/microsoft.public.vc.stl/browse_thread/thread/9a68d84644e64f15
+		MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
+				"UPDATE " << o.table() << " SET " << n.equal_list() <<
+				" WHERE " << o.equal_list(" AND ", sql_use_compare);
+		return *this;
+	}
+
+	/// \brief Insert a new row.
+	///
+	/// This function builds an INSERT SQL query.  One uses it with
+	/// MySQL++'s Specialized SQL Structures mechanism.
+	///
+	/// \param v new row
+	///
+	/// \sa replace(), update()
+	template <class T>
+	Query& insert(const T& v)
+	{
+		reset();
+
+		MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
+				"INSERT INTO " << v.table() << " (" <<
+				v.field_list() << ") VALUES (" <<
+				v.value_list() << ')';
+		return *this;
+	}
+
+	/// \brief Insert multiple new rows.
+	///
+	/// Builds an INSERT SQL query using items from a range within an
+	/// STL container.  Insert the entire contents of the container by
+	/// using the begin() and end() iterators of the container as
+	/// parameters to this function.
+	///
+	/// \param first iterator pointing to first element in range to
+	///    insert
+	/// \param last iterator pointing to one past the last element to
+	///    insert
+	///
+	/// \sa replace(), update()
+	template <class Iter>
+	Query& insert(Iter first, Iter last)
+	{
+		reset();
+		if (first == last) {
+			return *this;	// empty set!
+		}
+		
+		MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
+				"INSERT INTO " << first->table() << " (" <<
+				first->field_list() << ") VALUES (" <<
+				first->value_list() << ')';
+
+		Iter it = first + 1;
+		while (it != last) {
+			MYSQLPP_QUERY_THISPTR << ",(" << it->value_list() << ')';
+			++it;
+		}
+
+		return *this;
+	}
+
+	/// \brief Insert new row unless there is an existing row that
+	/// matches on a unique index, in which case we replace it.
+	///
+	/// This function builds a REPLACE SQL query.  One uses it with
+	/// MySQL++'s Specialized SQL Structures mechanism.
+	///
+	/// \param v new row
+	///
+	/// \sa insert(), update()
+	template <class T>
+	Query& replace(const T& v)
+	{
+		reset();
+
+		MYSQLPP_QUERY_THISPTR << std::setprecision(16) <<
+				"REPLACE INTO " << v.table() << " (" <<
+				v.field_list() << ") VALUES (" << v.value_list() << ')';
+		return *this;
+	}
+
+#if !defined(DOXYGEN_IGNORE)
+	// Declare the remaining overloads.  These are hidden down here partly
+	// to keep the above code clear, but also so that we may hide them
+	// from Doxygen, which gets confused by macro instantiations that look
+	// like method declarations.
+	mysql_query_define0(std::string, str)
+	mysql_query_define0(SimpleResult, execute)
+	mysql_query_define0(StoreQueryResult, store)
+	mysql_query_define0(UseQueryResult, use)
+	mysql_query_define1(storein_sequence)
+	mysql_query_define1(storein_set)
+	mysql_query_define1(storein)
+#endif // !defined(DOXYGEN_IGNORE)
+
+	/// \brief The default template parameters
+	///
+	/// Used for filling in parameterized queries.
+	SQLQueryParms template_defaults;
+
+private:
+	friend class SQLQueryParms;
+
+	/// \brief Connection to send queries through
+	Connection* conn_;
+
+	/// \brief If true, last query succeeded
+	bool copacetic_;
+
+	/// \brief List of template query parameters
+	std::vector<SQLParseElement> parse_elems_;
+
+	/// \brief Maps template parameter position values to the
+	/// corresponding parameter name.
+	std::vector<std::string> parsed_names_;
+
+	/// \brief Maps template parameter names to their position value.
+	std::map<std::string, short int> parsed_nums_;
+
+	/// \brief String buffer for storing assembled query
+	std::stringbuf sbuffer_;
+
+	/// \brief Process a parameterized query list.
+	void proc(SQLQueryParms& p);
+
+	SQLTypeAdapter* pprepare(char option, SQLTypeAdapter& S, bool replace = true);
+};
+
+
+/// \brief Insert raw query string into the given stream.
+///
+/// This is just syntactic sugar for Query::str(void)
+inline std::ostream& operator <<(std::ostream& os, Query& q)
+{
+	return os << q.str();
+}
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_QUERY_H)
+

ADDED   lib/querydef.h
Index: lib/querydef.h
==================================================================
--- /dev/null
+++ lib/querydef.h
@@ -0,0 +1,109 @@
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// This file is generated by the Perl script querydef.pl. Please do 
+// not modify this file directly. Change the script instead.
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+#ifndef MYSQLPP_QUERYDEF_H
+#define MYSQLPP_QUERYDEF_H
+
+#define mysql_query_define0(RETURN, FUNC) \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20, const SQLTypeAdapter& arg21) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20 << arg21); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20, const SQLTypeAdapter& arg21, const SQLTypeAdapter& arg22) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20 << arg21 << arg22); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20, const SQLTypeAdapter& arg21, const SQLTypeAdapter& arg22, const SQLTypeAdapter& arg23) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20 << arg21 << arg22 << arg23); } \
+	RETURN FUNC(const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20, const SQLTypeAdapter& arg21, const SQLTypeAdapter& arg22, const SQLTypeAdapter& arg23, const SQLTypeAdapter& arg24) \
+		{ return FUNC(SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20 << arg21 << arg22 << arg23 << arg24); } \
+
+#define mysql_query_define1(FUNC) \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20, const SQLTypeAdapter& arg21) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20 << arg21); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20, const SQLTypeAdapter& arg21, const SQLTypeAdapter& arg22) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20 << arg21 << arg22); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20, const SQLTypeAdapter& arg21, const SQLTypeAdapter& arg22, const SQLTypeAdapter& arg23) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20 << arg21 << arg22 << arg23); } \
+	template <class T> void FUNC(T& container, const SQLTypeAdapter& arg0, const SQLTypeAdapter& arg1, const SQLTypeAdapter& arg2, const SQLTypeAdapter& arg3, const SQLTypeAdapter& arg4, const SQLTypeAdapter& arg5, const SQLTypeAdapter& arg6, const SQLTypeAdapter& arg7, const SQLTypeAdapter& arg8, const SQLTypeAdapter& arg9, const SQLTypeAdapter& arg10, const SQLTypeAdapter& arg11, const SQLTypeAdapter& arg12, const SQLTypeAdapter& arg13, const SQLTypeAdapter& arg14, const SQLTypeAdapter& arg15, const SQLTypeAdapter& arg16, const SQLTypeAdapter& arg17, const SQLTypeAdapter& arg18, const SQLTypeAdapter& arg19, const SQLTypeAdapter& arg20, const SQLTypeAdapter& arg21, const SQLTypeAdapter& arg22, const SQLTypeAdapter& arg23, const SQLTypeAdapter& arg24) \
+		{ FUNC(container, SQLQueryParms() << arg0 << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 << arg8 << arg9 << arg10 << arg11 << arg12 << arg13 << arg14 << arg15 << arg16 << arg17 << arg18 << arg19 << arg20 << arg21 << arg22 << arg23 << arg24); } \
+
+#endif // !defined(MYSQLPP_QUERYDEF_H)

ADDED   lib/querydef.pl
Index: lib/querydef.pl
==================================================================
--- /dev/null
+++ lib/querydef.pl
@@ -0,0 +1,92 @@
+#!/usr/bin/perl -w
+
+########################################################################
+# querydef.pl - Generates querydef.h, which defines a number of macros
+#	used in query.h that differ only in the number of arguments.  That
+#	number limits the number of parameters a MySQL++ template query can
+#	accept.  This value can be changed from its default, below.
+#
+# Copyright (c) 2006-2008 by Educational Technology Resources, Inc.
+# Others may also hold copyrights on code in this file.  See the CREDITS
+# file in the top directory of the distribution for details.
+#
+# This file is part of MySQL++.
+#
+# MySQL++ is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with MySQL++; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+# USA
+########################################################################
+
+
+# The number of parameters a template query can accept.  Make this value
+# larger only at need, as it adds code to the library proportionally.
+# You should not reduce this value if programs you did not write may
+# link to the library, as that would constitute an ABI breakage.
+my $max_parameters = 25;
+
+
+# No user-serviceable parts below.
+
+use strict;
+
+open (OUT, ">querydef.h");
+
+print OUT << "---";
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// This file is generated by the Perl script querydef.pl. Please do 
+// not modify this file directly. Change the script instead.
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+#ifndef MYSQLPP_QUERYDEF_H
+#define MYSQLPP_QUERYDEF_H
+
+---
+
+## Build mysql_query_define0 macro
+print OUT "#define mysql_query_define0(RETURN, FUNC) \\\n";
+for (my $i = 1; $i < $max_parameters; ++$i) {
+	print OUT "\tRETURN FUNC(";
+	for (my $j = 0; $j < $i + 1; ++$j) {
+		print OUT 'const SQLTypeAdapter& arg', $j;
+		print OUT ', ' unless $j == $i;
+	}
+	print OUT ") \\\n";
+
+	print OUT "\t\t{ return FUNC(SQLQueryParms()";
+	for (my $j = 0; $j < $i + 1; ++$j) {
+		print OUT ' << arg', $j;
+	}
+	print OUT "); } \\\n";
+}
+print OUT "\n";
+
+## Add mysql_query_define1 macro
+print OUT "#define mysql_query_define1(FUNC) \\\n";
+for (my $i = 1; $i < $max_parameters; ++$i) {
+	print OUT "\ttemplate <class T> void FUNC(T& container";
+	for (my $j = 0; $j < $i + 1; ++$j) {
+		print OUT ', const SQLTypeAdapter& arg', $j;
+	}
+	print OUT ") \\\n";
+	print OUT "\t\t{ FUNC(container, SQLQueryParms()";
+	for (my $j = 0; $j < $i + 1; ++$j) {
+		print OUT ' << arg', $j;
+	}
+	print OUT "); } \\\n";
+}
+print OUT "\n";
+
+## That's all, folks!
+print OUT "#endif // !defined(MYSQLPP_QUERYDEF_H)\n";
+

ADDED   lib/refcounted.h
Index: lib/refcounted.h
==================================================================
--- /dev/null
+++ lib/refcounted.h
@@ -0,0 +1,265 @@
+/// \file refcounted.h
+/// \brief Declares the RefCountedPointer template
+
+/***********************************************************************
+ Copyright (c) 2007 by Educational Technology Resources, Inc. and
+ (c) 2007 by Jonathan Wakely.  Others may also hold copyrights on
+ code in this file.  See the CREDITS file in the top directory of
+ the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_REFCOUNTED_H)
+#define MYSQLPP_REFCOUNTED_H
+
+#include <memory>
+
+namespace mysqlpp {
+
+/// \brief Functor to call delete on the pointer you pass to it
+///
+/// The default "destroyer" for RefCountedPointer.  You won't use this
+/// directly, you'll pass a functor of your own devising for the second
+/// parameter to the RefCountedPointer template to override this.  Or
+/// simpler, just specialize this template for your type if possible:
+/// see ResUse::result_.
+template <class T>
+struct RefCountedPointerDestroyer
+{
+	/// \brief Functor implementation
+	void operator()(T* doomed) const { delete doomed; }
+};
+
+
+/// \brief Creates an object that acts as a reference-counted pointer
+/// to another object.
+///
+/// Resulting type acts like a pointer in all respects, except that it
+/// manages the memory it points to by observing how many users there
+/// are for the object.
+///
+/// This attempts to be as automatic as reference counting in a
+/// programming language with memory management.  Like all automatic
+/// memory management schemes, it has penalties: it turns the single
+/// indirection of an unmanaged pointer into a double indirection, and
+/// has additional management overhead in the assignment operators due
+/// to the reference counter.  This is an acceptable tradeoff when
+/// wrapping objects that are expensive to copy, and which need to
+/// be "owned" by disparate parties: you can allocate the object just
+/// once, then pass around the reference counted pointer, knowing that
+/// the last user will "turn out the lights".
+///
+/// \b Implementation \b detail: You may notice that this class manages
+/// two pointers, one to the data we're managing, and one to the
+/// reference count.  You might wonder why we don't wrap these up into a
+/// structure and keep just a pointer to an instance of it to simplify
+/// the memory management.  It would indeed do that, but then every
+/// access to the data we manage would be a triple indirection instead
+/// of just double.  It's a tradeoff, and we've chosen to take a minor
+/// complexity hit to avoid the performance hit.
+
+template <class T, class Destroyer = RefCountedPointerDestroyer<T> >
+class RefCountedPointer
+{
+public:
+	typedef RefCountedPointer<T> ThisType;	///< alias for this object's type
+
+	/// \brief Default constructor
+	///
+	/// An object constructed this way is useless until you vivify it
+	/// with operator =() or assign().
+	RefCountedPointer() :
+	counted_(0),
+	refs_(0)
+	{
+	}
+	
+	/// \brief Standard constructor
+	///
+	/// \param c A pointer to the object to be managed.  If you pass 0,
+	/// it's like calling the default ctor instead, only more work: the
+	/// object's useless until you vivify it with operator =() or assign().
+	explicit RefCountedPointer(T* c) :
+	counted_(c),
+	refs_(0)
+	{
+		std::auto_ptr<T> exception_guard(counted_);
+		if (counted_) {
+			refs_ = new size_t(1);
+		}
+		exception_guard.release();	// previous new didn't throw
+	}
+
+	/// \brief Copy constructor
+	RefCountedPointer(const ThisType& other) :
+	counted_(other.counted_),
+	refs_(other.counted_ ? other.refs_ : 0)
+	{
+		if (counted_) {
+			++(*refs_);
+		}
+	}
+
+	/// \brief Destructor
+	///
+	/// This only destroys the managed memory if the reference count
+	/// drops to 0.
+	~RefCountedPointer()
+	{
+		if (refs_ && (--(*refs_) == 0)) {
+			Destroyer()(counted_);
+			delete refs_;
+		}
+	}
+
+	/// \brief Sets (or resets) the pointer to the counted object.
+	///
+	/// If we are managing a pointer, this decrements the refcount for
+	/// it and destroys the managed object if the refcount falls to 0.
+	///
+	/// This is a no-op if you pass the same pointer we're already
+	/// managing.
+	ThisType& assign(T* c)
+	{
+		// The create-temporary-and-swap idiom lets us keep memory
+		// allocation in the ctor and deallocation in the dtor so
+		// we don't leak in the face of an exception.
+		ThisType(c).swap(*this);
+		return *this;
+	}
+
+	/// \brief Copy an existing refcounted pointer
+	///
+	/// If we are managing a pointer, this decrements the refcount for
+	/// it and destroys the managed object if the refcount falls to 0.
+	/// Then we increment the other object's reference count and copy
+	/// that refcount and the managed pointer into this object.
+	///
+	/// This is a no-op if you pass a reference to this same object.
+	ThisType& assign(const ThisType& other)
+	{
+		// The create-temporary-and-swap idiom lets us keep memory
+		// allocation in the ctor and deallocation in the dtor so
+		// we don't leak in the face of an exception.
+		ThisType(other).swap(*this);
+		return *this;
+	}
+
+	/// \brief Set (or reset) the pointer to the counted object
+	///
+	/// This is essentially the same thing as assign(T*).  The choice
+	/// between the two is just a matter of syntactic preference.
+	ThisType& operator =(T* c)
+	{
+		return assign(c);
+	}
+
+	/// \brief Copy an existing refcounted pointer
+	///
+	/// This is essentially the same thing as assign(const ThisType&).
+	/// The choice between the two is just a matter of syntactic
+	/// preference.
+	ThisType& operator =(const ThisType& rhs)
+	{
+		return assign(rhs);
+	}
+
+	/// \brief Access the object through the smart pointer
+	T* operator ->() const
+	{
+		return counted_;
+	}	
+
+	/// \brief Dereference the smart pointer
+	T& operator *() const
+	{
+		return *counted_;
+	}	
+
+	/// \brief Returns the internal raw pointer converted to void*
+	///
+	/// This isn't intended to be used directly; if you need the
+	/// pointer, call raw() instead.  It's used internally by the
+	/// compiler to implement operators bool, ==, and !=
+	///
+	/// \b WARNING: This makes it possible to say
+	/// \code
+	/// RefCountedPointer<Foo> bar(new Foo);
+	/// delete bar;
+	/// \endcode
+	///
+	/// This will almost kinda sorta do the right thing: the Foo
+	/// object held by the refcounted pointer will be destroyed as
+	/// you wanted, but then when the refcounted pointer goes out of
+	/// scope, the memory is deleted a second time, which will probably
+	/// crash your program.  This is easy to accidentally do when
+	/// converting a good ol' unmanaged pointer to a refcounted pointer
+	/// and forgetting to remove the delete calls needed previously.
+	operator void*()
+	{
+		return counted_;
+	}
+
+	/// \brief Returns the internal raw pointer converted to const void*
+	///
+	/// \see comments for operator void*()
+	operator const void*() const
+	{
+		return counted_;
+	}
+
+	/// \brief Return the raw pointer in T* context
+	T* raw()
+	{
+		return counted_;
+	}
+
+	/// \brief Return the raw pointer when used in const T* context
+	const T* raw() const
+	{
+		return counted_;
+	}
+
+	/// \brief Exchange our managed memory with another pointer.
+	///
+	/// \internal This exists primarily to implement assign() in an
+	/// exception-safe manner.
+	void swap(ThisType& other)
+	{
+		std::swap(counted_, other.counted_);
+		std::swap(refs_, other.refs_);
+	}	
+
+private:
+	/// \brief Pointer to the reference-counted object
+	T* counted_;
+
+	/// \brief Pointer to the reference count.
+	///
+	/// We can't keep this as a plain integer because this object
+	/// allows itself to be copied.  All copies need to share this
+	/// reference count, not just the pointer to the counted object.
+	size_t* refs_;
+};
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_REFCOUNTED_H)
+

ADDED   lib/result.cpp
Index: lib/result.cpp
==================================================================
--- /dev/null
+++ lib/result.cpp
@@ -0,0 +1,210 @@
+/***********************************************************************
+ result.cpp - Implements the ResultBase, StoreQueryResult and
+ 	UseQuery Result classes.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in the
+ top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "result.h"
+
+#include "dbdriver.h"
+
+
+namespace mysqlpp {
+
+
+ResultBase::ResultBase(MYSQL_RES* res, DBDriver* dbd, bool te) :
+OptionalExceptions(te),
+driver_(res ? dbd : 0),
+fields_(Fields::size_type(res ? dbd->num_fields(res) : 0)),
+current_field_(0)
+{
+	if (res) {
+		Fields::size_type i = 0;
+		const MYSQL_FIELD* pf;
+		while ((i < fields_.size()) && (pf = dbd->fetch_field(res))) {
+			fields_[i++] = pf;
+		}
+		dbd->field_seek(res, 0);		// semantics break otherwise!
+
+		names_ = new FieldNames(this);
+		types_ = new FieldTypes(this);
+	}
+}
+
+
+ResultBase&
+ResultBase::copy(const ResultBase& other)
+{
+	if (this != &other) {
+		set_exceptions(other.throw_exceptions());
+
+		if (other.driver_) {
+			driver_ = other.driver_;
+			fields_ = other.fields_;
+			names_ = other.names_;
+			types_ = other.types_;
+			current_field_ = other.current_field_;
+		}
+		else {
+			driver_ = 0;
+			fields_.clear();
+			names_ = 0;
+			types_ = 0;
+			current_field_ = 0;
+		}
+	}
+
+	return *this;
+}
+
+
+int
+ResultBase::field_num(const std::string& i) const
+{
+	size_t index = (*names_)[i];
+	if ((index >= names_->size()) && throw_exceptions()) {
+		if (throw_exceptions()) {
+            throw BadFieldName(i.c_str());
+        }
+        else {
+            return -1;
+        }
+	}
+	
+	return int(index);
+}
+
+
+StoreQueryResult::StoreQueryResult(MYSQL_RES* res, DBDriver* dbd,
+		bool te) :
+ResultBase(res, dbd, te),
+list_type(list_type::size_type(res && dbd ? dbd->num_rows(res) : 0)),
+copacetic_(res && dbd)
+{
+	if (copacetic_) {
+		iterator it = begin();
+		while (MYSQL_ROW row = dbd->fetch_row(res)) {
+			if (const unsigned long* lengths = dbd->fetch_lengths(res)) {
+				*it = Row(row, this, lengths, throw_exceptions());
+				++it;
+			}
+		}
+
+		dbd->free_result(res);
+	}
+}
+
+
+StoreQueryResult&
+StoreQueryResult::copy(const StoreQueryResult& other)
+{
+	if (this != &other) {
+		ResultBase::copy(other);
+		assign(other.begin(), other.end());
+		copacetic_ = other.copacetic_;
+	}
+
+	return *this;
+}
+
+
+UseQueryResult::UseQueryResult(MYSQL_RES* res, DBDriver* dbd, bool te) :
+ResultBase(res, dbd, te)
+{
+	if (res) {
+		result_ = res;
+	}
+}
+
+
+UseQueryResult&
+UseQueryResult::copy(const UseQueryResult& other)
+{
+	if (this != &other) {
+		ResultBase::copy(other);
+		if (other.result_) {
+			result_ = other.result_;
+		}
+		else {
+			result_ = 0;
+		}
+	}
+
+	return *this;
+}
+
+
+const unsigned long*
+UseQueryResult::fetch_lengths() const
+{
+	return driver_->fetch_lengths(result_.raw());
+}
+
+
+Row
+UseQueryResult::fetch_row() const
+{
+	if (!result_) {
+		if (throw_exceptions()) {
+			throw UseQueryError("Results not fetched");
+		}
+		else {
+			return Row();
+		}
+	}
+
+	MYSQL_ROW row = driver_->fetch_row(result_.raw());
+	if (row) {
+		const unsigned long* lengths = fetch_lengths();
+		if (lengths) {
+			return Row(row, this, lengths, throw_exceptions());
+		}
+		else {
+			if (throw_exceptions()) {
+				throw UseQueryError("Failed to get field lengths");
+			}
+			else {
+				return Row();
+			}
+		}
+	}
+	else {
+		// Prior to v3, this was considered an error, but it just means
+		// we've fallen off the end of a "use" query's result set.  You
+		// can't predict when this will happen, but it isn't an error.
+		// Just return a falsy row object so caller's loop terminates.
+		return Row();
+	}
+}
+
+
+MYSQL_ROW
+UseQueryResult::fetch_raw_row() const
+{
+	return driver_->fetch_row(result_.raw());
+}
+
+
+} // end namespace mysqlpp
+

ADDED   lib/result.h
Index: lib/result.h
==================================================================
--- /dev/null
+++ lib/result.h
@@ -0,0 +1,425 @@
+/// \file result.h
+/// \brief Declares classes for holding information about SQL query
+/// results.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_RESULT_H)
+#define MYSQLPP_RESULT_H
+
+#include "common.h"
+
+#include "exceptions.h"
+#include "field.h"
+#include "field_names.h"
+#include "field_types.h"
+#include "noexceptions.h"
+#include "refcounted.h"
+#include "row.h"
+
+namespace mysqlpp {
+
+
+/// \brief Holds information about the result of queries that don't
+/// return rows.
+
+class MYSQLPP_EXPORT SimpleResult
+{
+private:
+	/// \brief Pointer to bool data member, for use by safe bool
+	/// conversion operator.
+	///
+	/// \see http://www.artima.com/cppsource/safebool.html
+    typedef bool SimpleResult::*private_bool_type;
+
+public:
+	/// \brief Default ctor
+	SimpleResult() :
+	copacetic_(false),
+	insert_id_(0),
+	rows_(0)
+	{
+	}
+
+	/// \brief Initialize object
+	SimpleResult(bool copacetic, ulonglong insert_id,
+			ulonglong rows, const std::string& info) :
+	copacetic_(copacetic),
+	insert_id_(insert_id),
+	rows_(rows),
+	info_(info)
+	{
+	}
+
+	/// \brief Test whether the query that created this result succeeded
+	///
+	/// If you test this object in bool context and it's false, it's a
+	/// signal that the query this was created from failed in some way.
+	/// Call Query::error() or Query::errnum() to find out what exactly
+	/// happened.
+	operator private_bool_type() const
+	{
+		return copacetic_ ? &SimpleResult::copacetic_ : 0;
+	}
+
+	/// \brief Get the last value used for an AUTO_INCREMENT field
+	ulonglong insert_id() const { return insert_id_; }
+
+	/// \brief Get the number of rows affected by the query
+	ulonglong rows() const { return rows_; }
+
+	/// \brief Get any additional information about the query returned
+	/// by the server.
+	const char* info() const { return info_.c_str(); }
+
+private:
+	bool copacetic_;
+	ulonglong insert_id_;
+	ulonglong rows_;
+	std::string info_;
+};
+
+
+/// \brief Base class for StoreQueryResult and UseQueryResult.
+///
+/// Not useful directly.  Just contains common functionality for its
+/// subclasses.
+
+class MYSQLPP_EXPORT ResultBase : public OptionalExceptions
+{
+public:
+	/// \brief Destroy object
+	virtual ~ResultBase() { }
+
+	/// \brief Returns the next field in this result set
+	const Field& fetch_field() const
+			{ return fields_.at(current_field_++); }
+
+	/// \brief Returns the given field in this result set
+	const Field& fetch_field(Fields::size_type i) const
+			{ return fields_.at(i); }
+
+	/// \brief Get the underlying Field structure given its index.
+	const Field& field(unsigned int i) const { return fields_.at(i); }
+
+	/// \brief Get the underlying Fields structure.
+	const Fields& fields() const { return fields_; }
+
+	/// \brief Get the name of the field at the given index.
+	const std::string& field_name(int i) const
+			{ return names_->at(i); }
+
+	/// \brief Get the names of the fields within this result set.
+	const RefCountedPointer<FieldNames>& field_names() const
+			{ return names_; }
+
+	/// \brief Get the index of the named field.
+	///
+	/// This is the inverse of field_name().
+	int field_num(const std::string&) const;
+
+	/// \brief Get the type of a particular field within this result set.
+	const FieldTypes::value_type& field_type(int i) const
+			{ return types_->at(i); }
+
+	/// \brief Get a list of the types of the fields within this
+	/// result set.
+	const RefCountedPointer<FieldTypes>& field_types() const
+			{ return types_; }
+
+	/// \brief Returns the number of fields in this result set
+	size_t num_fields() const { return fields_.size(); }
+
+	/// \brief Return the name of the table the result set comes from
+	const char* table() const
+			{ return fields_.empty() ? "" : fields_[0].table(); }
+
+protected:
+	/// \brief Create empty object
+	ResultBase() :
+	driver_(0),
+	current_field_(0)
+	{
+	}
+	
+	/// \brief Create the object, fully initialized
+	ResultBase(MYSQL_RES* result, DBDriver* dbd, bool te = true);
+	
+	/// \brief Create object as a copy of another ResultBase
+	ResultBase(const ResultBase& other) :
+	OptionalExceptions()
+	{
+		copy(other);
+	}
+
+	/// \brief Copy another ResultBase object's contents into this one.
+	ResultBase& copy(const ResultBase& other);
+
+	DBDriver* driver_;	///< Access to DB driver; fully initted if nonzero
+	Fields fields_;		///< list of fields in result
+
+	/// \brief list of field names in result
+	RefCountedPointer<FieldNames> names_;
+
+	/// \brief list of field types in result
+	RefCountedPointer<FieldTypes> types_;
+
+	/// \brief Default field index used by fetch_field()
+	///
+	/// It's mutable because it's just internal housekeeping: it's
+	/// changed by fetch_field(void), but it doesn't change the "value"
+	/// of the result.  See mutability justification for
+	/// UseQueryResult::result_: this field provides functionality we
+	/// used to get through result_, so it's relevant here, too.
+	mutable Fields::size_type current_field_;
+};
+
+
+/// \brief StoreQueryResult set type for "store" queries
+///
+/// This is the obvious C++ implementation of a class to hold results 
+/// from a SQL query that returns rows: a specialization of std::vector
+/// holding Row objects in memory so you get random-access semantics.
+/// MySQL++ also supports UseQueryResult which is less friendly, but has
+/// better memory performance.  See the user manual for more details on
+/// the distinction and the usage patterns required.
+
+class MYSQLPP_EXPORT StoreQueryResult :
+		public ResultBase,
+		public std::vector<Row>
+{
+private:
+	/// \brief Pointer to bool data member, for use by safe bool
+	/// conversion operator.
+	///
+	/// \see http://www.artima.com/cppsource/safebool.html
+    typedef bool StoreQueryResult::*private_bool_type;
+
+public:
+	typedef std::vector<Row> list_type;	///< type of vector base class
+
+	/// \brief Default constructor
+	StoreQueryResult() :
+	ResultBase(),
+	copacetic_(false)
+	{
+	}
+	
+	/// \brief Fully initialize object
+	StoreQueryResult(MYSQL_RES* result, DBDriver* dbd, bool te = true);
+
+	/// \brief Initialize object as a copy of another StoreQueryResult
+	/// object
+	StoreQueryResult(const StoreQueryResult& other) :
+	ResultBase(),
+	std::vector<Row>(),
+	copacetic_(false)
+	{
+		copy(other);
+	}
+
+	/// \brief Destroy result set
+	~StoreQueryResult() { }
+
+	/// \brief Returns the number of rows in this result set
+	list_type::size_type num_rows() const { return size(); }
+
+	/// \brief Copy another StoreQueryResult object's data into this
+	/// object
+	StoreQueryResult& operator =(const StoreQueryResult& rhs)
+			{ return this != &rhs ? copy(rhs) : *this; }
+
+	/// \brief Test whether the query that created this result succeeded
+	///
+	/// If you test this object in bool context and it's false, it's a
+	/// signal that the query this was created from failed in some way.
+	/// Call Query::error() or Query::errnum() to find out what exactly
+	/// happened.
+	operator private_bool_type() const
+	{
+		return copacetic_ ? &StoreQueryResult::copacetic_ : 0;
+	}
+
+private:
+	/// \brief Copy another StoreQueryResult object's contents into this
+	/// one.
+	StoreQueryResult& copy(const StoreQueryResult& other);
+
+	bool copacetic_;	///< true if initialized from a good result set
+};
+
+
+/// \brief Functor to call mysql_free_result() on the pointer you pass
+/// to it.
+///
+/// This overrides RefCountedPointer's default destroyer, which uses
+/// operator delete; it annoys the C API when you nuke its data
+/// structures this way. :)
+template <>
+struct RefCountedPointerDestroyer<MYSQL_RES>
+{
+	/// \brief Functor implementation
+	void operator()(MYSQL_RES* doomed) const
+	{
+		if (doomed) {
+			mysql_free_result(doomed);
+		}
+	}
+};
+
+
+/// \brief StoreQueryResult set type for "use" queries
+///
+/// See the user manual for the reason you might want to use this even
+/// though its interface is less friendly than StoreQueryResult's.
+
+class MYSQLPP_EXPORT UseQueryResult : public ResultBase
+{
+public:
+	/// \brief Default constructor
+	UseQueryResult() :
+	ResultBase()
+	{
+	}
+	
+	/// \brief Create the object, fully initialized
+	UseQueryResult(MYSQL_RES* result, DBDriver* dbd, bool te = true);
+	
+	/// \brief Create a copy of another UseQueryResult object
+	UseQueryResult(const UseQueryResult& other) :
+	ResultBase()
+	{
+		copy(other);
+	}
+	
+	/// \brief Destroy object
+	~UseQueryResult() { }
+
+	/// \brief Copy another UseQueryResult object's data into this object
+	UseQueryResult& operator =(const UseQueryResult& rhs)
+			{ return this != &rhs ? copy(rhs) : *this; }
+
+	/// \brief Returns the next field in this result set
+	const Field& fetch_field() const
+			{ return fields_.at(current_field_++); }
+
+	/// \brief Returns the given field in this result set
+	const Field& fetch_field(Fields::size_type i) const
+			{ return fields_.at(i); }
+
+	/// \brief Returns the lengths of the fields in the current row of
+	/// the result set.
+	///
+	/// \internal This should not be terribly useful to end-user code.
+	/// The Row object returned by fetch_row() contains these lengths.
+	const unsigned long* fetch_lengths() const;
+
+	/// \brief Returns the next row in a "use" query's result set
+	///
+	/// This is a thick wrapper around DBDriver::fetch_row().  It does a
+	/// lot of error checking before returning the Row object containing
+	/// the row data.
+	///
+	/// \sa fetch_raw_row()
+	Row fetch_row() const;
+
+	/// \brief Wraps mysql_fetch_row() in MySQL C API.
+	///
+	/// \internal You almost certainly want to call fetch_row() instead.
+	/// It is anticipated that this is only useful within the library,
+	/// to implement higher-level query types on top of raw "use"
+	/// queries. Query::storein() uses it, for example.
+	MYSQL_ROW fetch_raw_row() const;
+
+	/// \brief Jumps to the given field within the result set
+	///
+	/// Calling this allows you to reset the default field index used
+	/// by fetch_field().
+	void field_seek(Fields::size_type field) const
+			{ current_field_ = field; }
+
+	/// \brief Return the pointer to the underlying MySQL C API
+	/// result set object.
+	///
+	/// While this has obvious inherent value for those times you need
+	/// to dig beneath the MySQL++ interface, it has subtler value.
+	/// It effectively stands in for operator bool(), operator !(),
+	/// operator ==(), and operator !=(), because the C++ compiler can
+	/// implement all of these with a MYSQL_RES*.
+	///
+	/// Of these uses, the most valuable is using the UseQueryResult
+	/// object in bool context to determine if the query that created
+	// it was successful:
+	///
+	/// \code
+	///   Query q("....");
+	///   if (UseQueryResult res = q.use()) {
+	///       // Can use 'res', query succeeded
+	///   }
+	///   else {
+	///       // Query failed, call Query::error() or ::errnum() for why
+	///   }
+	/// \endcode
+	operator MYSQL_RES*() const { return result_.raw(); }
+	
+private:
+	/// \brief Copy another ResultBase object's contents into this one.
+	UseQueryResult& copy(const UseQueryResult& other);
+
+	/// \brief Reference to underlying C API result set
+	///
+	/// This is mutable because so many methods in this class are
+	/// are justifiably const because they don't modify the result
+	/// set's "value" but they call C API methods that take non-const
+	/// MYSQL_RES* so they can only be const if this is mutable.  It's
+	/// quite likely that these API functions do modify the MYSQL_RES
+	/// object, so strict constness says this object changed, too, but
+	/// this has always been mutable and the resulting behavior hasn't 
+	/// confused anyone yet.
+	mutable RefCountedPointer<MYSQL_RES> result_;
+};
+
+
+/// \brief Swaps two StoreQueryResult objects
+inline void
+swap(StoreQueryResult& x, StoreQueryResult& y)
+{
+	StoreQueryResult tmp = x;
+	x = y;
+	y = tmp;
+}
+
+/// \brief Swaps two UseQueryResult objects
+inline void
+swap(UseQueryResult& x, UseQueryResult& y)
+{
+	UseQueryResult tmp = x;
+	x = y;
+	y = tmp;
+}
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_RESULT_H)

ADDED   lib/row.cpp
Index: lib/row.cpp
==================================================================
--- /dev/null
+++ lib/row.cpp
@@ -0,0 +1,197 @@
+/***********************************************************************
+ row.cpp - Implements the Row class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "row.h"
+
+#include "result.h"
+
+
+namespace mysqlpp {
+
+Row::Row(MYSQL_ROW row, const ResultBase* res,
+		const unsigned long* lengths, bool throw_exceptions) :
+OptionalExceptions(throw_exceptions),
+initialized_(false)
+{
+	if (row) {
+		if (res) {
+			size_type size = res->num_fields();
+			data_.reserve(size);
+			for (size_type i = 0; i < size; ++i) {
+				bool is_null = row[i] == 0;
+				data_.push_back(value_type(
+						is_null ? "NULL" : row[i],
+						is_null ? 4 : lengths[i],
+						res->field_type(i),
+						is_null));
+			}
+
+			field_names_ = res->field_names();
+			initialized_ = true;
+		}
+		else if (throw_exceptions) {
+			throw ObjectNotInitialized("RES is NULL");
+		}
+	}
+	else if (throw_exceptions) {
+		throw ObjectNotInitialized("ROW is NULL");
+	}
+}
+
+
+equal_list_ba<FieldNames, Row, quote_type0>
+Row::equal_list(const char* d, const char* e) const
+{
+	return equal_list_ba<FieldNames, Row, quote_type0>(
+			*field_names_, *this, d, e, quote);
+}
+
+
+template <class Manip>
+equal_list_ba<FieldNames, Row, Manip>
+Row::equal_list(const char* d, const char* e, Manip m) const 
+{
+	return equal_list_ba<FieldNames, Row, Manip>(
+			*field_names_, *this, d, e, m);
+}
+
+
+value_list_ba<FieldNames, do_nothing_type0>
+Row::field_list(const char* d) const
+{
+	return value_list_ba<FieldNames, do_nothing_type0>
+			(*field_names_, d, do_nothing);
+}
+
+
+template <class Manip>
+value_list_ba<FieldNames, Manip>
+Row::field_list(const char *d, Manip m) const
+{
+	return value_list_ba<FieldNames, Manip>(*field_names_, d, m);
+}
+
+
+template <class Manip>
+value_list_b<FieldNames, Manip>
+Row::field_list(const char *d, Manip m, const std::vector<bool>& vb) const
+{
+	return value_list_b<FieldNames, Manip>(*field_names_, vb, d, m);
+}
+
+
+value_list_b<FieldNames, quote_type0>
+Row::field_list(const char* d, const std::vector<bool>& vb) const
+{
+	return value_list_b<FieldNames, quote_type0>(*field_names_,
+			vb, d, quote);
+}
+
+
+value_list_b<FieldNames, quote_type0>
+Row::field_list(const std::vector<bool>& vb) const
+{
+	return value_list_b<FieldNames, quote_type0>(*field_names_,
+			vb, ",", quote);
+}
+
+
+template <class Manip> value_list_b<FieldNames, Manip>
+Row::field_list(const char* d, Manip m, bool t0, bool t1, bool t2,
+		bool t3, bool t4, bool t5, bool t6, bool t7, bool t8, bool t9,
+		bool ta, bool tb, bool tc) const
+{
+	std::vector<bool> vb;
+	create_vector(field_names_->size(), vb, t0, t1, t2, t3, t4,
+			t5, t6, t7, t8, t9, ta, tb, tc);
+	return value_list_b<FieldNames, Manip>(*field_names_, vb, d, m);
+}
+
+
+value_list_b<FieldNames, quote_type0>
+Row::field_list(const char *d, bool t0, bool t1, bool t2, bool t3,
+		bool t4, bool t5, bool t6, bool t7, bool t8, bool t9, bool ta,
+		bool tb, bool tc) const
+{
+	std::vector<bool> vb;
+	create_vector(field_names_->size(), vb, t0, t1, t2, t3, t4,
+			t5, t6, t7, t8, t9, ta, tb, tc);
+	return value_list_b<FieldNames, quote_type0>(*field_names_,
+			vb, d, quote);
+}
+
+
+value_list_b<FieldNames, quote_type0>
+Row::field_list(bool t0, bool t1, bool t2, bool t3, bool t4, bool t5,
+		bool t6, bool t7, bool t8, bool t9, bool ta, bool tb,
+		bool tc) const
+{
+	std::vector<bool> vb;
+	create_vector(field_names_->size(), vb, t0, t1, t2, t3, t4,
+			t5, t6, t7, t8, t9, ta, tb, tc);
+	return value_list_b<FieldNames, quote_type0>(*field_names_,
+			vb, ",", quote);
+}
+
+
+Row::size_type
+Row::field_num(const char* name) const
+{
+	if (field_names_) {
+		return (*field_names_)[name];
+	}
+	else {
+		if (throw_exceptions()) {
+			throw BadFieldName(name);
+		}
+		else {
+			return 0;
+		}
+	}
+}
+
+
+const Row::value_type&
+Row::operator [](const char* field) const
+{
+	size_type si = field_num(field);
+	if (si < size()) {
+		return at(si);
+	}
+	else {
+		if (throw_exceptions()) {
+			throw BadFieldName(field);
+		}
+		else {
+			static value_type empty;
+			return empty;
+		}
+	}
+}
+
+
+} // end namespace mysqlpp
+

ADDED   lib/row.h
Index: lib/row.h
==================================================================
--- /dev/null
+++ lib/row.h
@@ -0,0 +1,527 @@
+/// \file row.h
+/// \brief Declares the classes for holding row data from a result set.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_ROW_H)
+#define MYSQLPP_ROW_H
+
+#include "common.h"
+
+#include "mystring.h"
+#include "noexceptions.h"
+#include "refcounted.h"
+#include "vallist.h"
+
+#include <vector>
+#include <string>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class FieldNames;
+class MYSQLPP_EXPORT ResultBase;
+#endif
+
+/// \brief Manages rows from a result set.
+///
+/// This class is like an extended version of a \c const \c std::vector
+/// of mysqlpp::String.  It adds stuff for populating the vector.  As
+/// for why it's \c const, what would it mean to modify a Row?  If we
+/// ever did support such semantics, it should probably actually modify
+/// the database.  We can't do that if we just derive from std::vector.
+///
+/// Not that we could derive from std::vector even if we wanted to:
+/// \c vector::operator[](size_type) would interfere with our
+/// \c operator[](const \c char*).  We can avoid this only by
+/// maintaining our own public inteface independent of that of
+/// \c vector.
+
+class MYSQLPP_EXPORT Row : public OptionalExceptions
+{
+private:
+	/// \brief Pointer to bool data member, for use by safe bool
+	/// conversion operator.
+	///
+	/// \see http://www.artima.com/cppsource/safebool.html
+    typedef bool Row::*private_bool_type;
+
+public:
+	/// \brief type of our internal data list
+	///
+	/// This is public because all other typedefs we have for
+	/// mirroring std::vector's public interface depend on it.
+	typedef std::vector<String> list_type;
+
+	/// \brief constant iterator type
+	typedef list_type::const_iterator const_iterator;
+
+	/// \brief constant reference type
+	typedef list_type::const_reference const_reference;
+
+	/// \brief const reverse iterator type
+	typedef list_type::const_reverse_iterator const_reverse_iterator;
+
+	/// \brief type for index differences
+	typedef list_type::difference_type difference_type;
+
+	/// \brief iterator type
+	///
+	/// Note that this is just an alias for the const iterator.  Row
+	/// is immutable, but people are in the habit of saying 'iterator'
+	/// even when they don't intend to use the iterator to modify the
+	/// container, so we provide this as a convenience.
+	typedef const_iterator iterator;
+
+	/// \brief reference type
+	///
+	/// \sa iterator for justification for this const_reference alias
+	typedef const_reference reference;
+
+	/// \brief mutable reverse iterator type
+	///
+	/// \sa iterator for justification for this const_reverse_iterator
+	/// alias
+	typedef const_reverse_iterator reverse_iterator;
+
+	/// \brief type of returned sizes
+	typedef list_type::size_type size_type;
+
+	/// \brief type of data in container
+	typedef list_type::value_type value_type;
+
+	/// \brief Default constructor
+	Row() :
+	initialized_(false)
+	{
+	}
+	
+	/// \brief Copy constructor
+	Row(const Row& r) :
+	OptionalExceptions(),
+	data_(r.data_.begin(), r.data_.end()),
+	field_names_(r.field_names_),
+	initialized_(r.initialized_)
+	{
+	}
+
+	/// \brief Create a row object
+	///
+	/// \param row MySQL C API row data
+	/// \param res result set that the row comes from
+	/// \param lengths length of each item in row
+	/// \param te if true, throw exceptions on errors
+	Row(MYSQL_ROW row, const ResultBase* res,
+			const unsigned long* lengths, bool te = true);
+
+	/// \brief Destroy object
+	~Row() { }
+
+	/// \brief Get a const reference to the field given its index
+	///
+	/// If the index value is bad, the underlying std::vector is
+	/// supposed to throw an exception, according to the Standard.
+	const_reference at(size_type i) const { return data_.at(i); }
+
+	/// \brief Get a reference to the last element of the vector
+	const_reference back() const { return data_.back(); }
+
+	/// \brief Return a const iterator pointing to first element in the
+	/// container
+	const_iterator begin() const { return data_.begin(); }
+
+	/// \brief Returns true if container is empty
+	bool empty() const { return data_.empty(); }
+
+	/// \brief Return a const iterator pointing to one past the last
+	/// element in the container
+	const_iterator end() const { return data_.end(); }
+
+	/// \brief Get an "equal list" of the fields and values in this row
+	///
+	/// When inserted into a C++ stream, the delimiter 'd' will be used
+	/// between the items, " = " is the relationship operator, and items
+	/// will be quoted and escaped.
+	equal_list_ba<FieldNames, Row, quote_type0>
+			equal_list(const char* d = ",", const char* e = " = ") const;
+
+	/// \brief Get an "equal list" of the fields and values in this row
+	///
+	/// This method's parameters govern how the returned list will
+	/// behave when you insert it into a C++ stream:
+	///
+	/// \param d delimiter to use between items
+	/// \param e the operator to use between elements
+	/// \param m the manipulator to use for each element
+	///
+	/// For example, if d is ",", e is " = ", and m is the quote
+	/// manipulator, then the field and value lists (a, b) (c, d'e)
+	/// will yield an equal list that gives the following when inserted
+	/// into a C++ stream:
+	///
+	/// \code
+	///   'a' = 'c', 'b' = 'd''e'
+	/// \endcode
+	///
+	/// Notice how the single quote was 'escaped' in the SQL way to
+	/// avoid a syntax error.
+	template <class Manip>
+	equal_list_ba<FieldNames, Row, Manip> equal_list(const char* d,
+			const char* e, Manip m) const;
+
+	/// \brief Get a list of the field names in this row
+	///
+	/// When inserted into a C++ stream, the delimiter 'd' will be used
+	/// between the items, and no manipulator will be used on the items.
+	value_list_ba<FieldNames, do_nothing_type0>
+			field_list(const char* d = ",") const;
+
+	/// \brief Get a list of the field names in this row
+	///
+	/// \param d delimiter to place between the items when the list is
+	/// inserted into a C++ stream
+	/// \param m manipulator to use before each item when the list is
+	/// inserted into a C++ stream
+	template <class Manip>
+	value_list_ba<FieldNames, Manip> field_list(const char* d,
+			Manip m) const;
+
+	/// \brief Get a list of the field names in this row
+	///
+	/// \param d delimiter to place between the items when the list is
+	/// inserted into a C++ stream
+	/// \param m manipulator to use before each item when the list is
+	/// inserted into a C++ stream
+	/// \param vb for each true item in this list, add that field name
+	/// to the returned list; ignore the others
+	template <class Manip>
+	value_list_b<FieldNames, Manip> field_list(const char* d, Manip m,
+			const std::vector<bool>& vb) const;
+
+	/// \brief Get a list of the field names in this row
+	///
+	/// \param d delimiter to place between the items when the list is
+	/// inserted into a C++ stream
+	/// \param vb for each true item in this list, add that field name
+	/// to the returned list; ignore the others
+	///
+	/// Field names will be quoted and escaped when inserted into a C++
+	/// stream.
+	value_list_b<FieldNames, quote_type0> field_list(
+			const char* d, const std::vector<bool>& vb) const;
+
+	/// \brief Get a list of the field names in this row
+	///
+	/// \param vb for each true item in this list, add that field name
+	/// to the returned list; ignore the others
+	///
+	/// Field names will be quoted and escaped when inserted into a C++
+	/// stream, and a comma will be placed between them as a delimiter.
+	value_list_b<FieldNames, quote_type0> field_list(
+			const std::vector<bool>& vb) const;
+
+	/// \brief Get a list of the field names in this row
+	///
+	/// For each true parameter, the field name in that position within
+	/// the row is added to the returned list.  When the list is
+	/// inserted into a C++ stream, the delimiter 'd' will be placed
+	/// between the items as a delimiter, and the manipulator 'm' used
+	/// before each item.
+	template <class Manip>
+	value_list_b<FieldNames, Manip> field_list(const char *d, Manip m,
+			bool t0,
+			bool t1 = false, bool t2 = false, bool t3 = false,
+			bool t4 = false, bool t5 = false, bool t6 = false,
+			bool t7 = false, bool t8 = false, bool t9 = false,
+			bool ta = false, bool tb = false, bool tc = false) const;
+
+	/// \brief Get a list of the field names in this row
+	///
+	/// For each true parameter, the field name in that position within
+	/// the row is added to the returned list.  When the list is
+	/// inserted into a C++ stream, the delimiter 'd' will be placed
+	/// between the items as a delimiter, and the items will be quoted
+	/// and escaped.
+	value_list_b<FieldNames, quote_type0> field_list(
+			const char *d, bool t0,
+			bool t1 = false, bool t2 = false, bool t3 = false,
+			bool t4 = false, bool t5 = false, bool t6 = false,
+			bool t7 = false, bool t8 = false, bool t9 = false,
+			bool ta = false, bool tb = false, bool tc = false) const;
+
+	/// \brief Get a list of the field names in this row
+	///
+	/// For each true parameter, the field name in that position within
+	/// the row is added to the returned list.  When the list is
+	/// inserted into a C++ stream, a comma will be placed between the
+	/// items as a delimiter, and the items will be quoted and escaped.
+	value_list_b<FieldNames, quote_type0> field_list(
+			bool t0,
+			bool t1 = false, bool t2 = false, bool t3 = false,
+			bool t4 = false, bool t5 = false, bool t6 = false,
+			bool t7 = false, bool t8 = false, bool t9 = false,
+			bool ta = false, bool tb = false, bool tc = false) const;
+
+	/// \brief Returns a field's index given its name
+	size_type field_num(const char* name) const;
+
+	/// \brief Get a reference to the first element of the vector
+	const_reference front() const { return data_.front(); }
+
+	/// \brief Return maximum number of elements that can be stored
+	/// in container without resizing.
+	size_type max_size() const { return data_.max_size(); }
+
+	/// \brief Assignment operator
+	Row& operator =(const Row& rhs)
+	{
+		data_.assign(rhs.data_.begin(), rhs.data_.end());
+		field_names_.assign(rhs.field_names_);
+		initialized_ = rhs.initialized_;
+		return *this;
+	}
+
+	/// \brief Get the value of a field given its name.
+	///
+	/// If the field does not exist in this row, we throw a BadFieldName
+	/// exception.
+	///
+	/// This operator is fairly inefficient.  operator[](int) is faster.
+	const_reference operator [](const char* field) const;
+
+	/// \brief Get the value of a field given its index.
+	///
+	/// This function is just syntactic sugar, wrapping the at() method.
+	///
+	/// It's \b critical that the parameter type be \c int, not
+	/// \c size_type, because it will interfere with the \c const
+	/// \c char* overload otherwise.  row[0] is ambiguous when there
+	/// isn't an int overload.
+	const_reference operator [](int i) const
+			{ return at(static_cast<size_type>(i)); }
+
+	/// \brief Returns true if row object was fully initialized and
+	/// has data.
+	///
+	/// This operator lets you use Row in bool context, which lets you
+	/// do things like tell when you've run off the end of a "use"
+	/// query's result set:
+	///
+	/// \code
+	///   Query q("....");
+	///   if (UseQueryResult res = q.use()) {
+	///       // Can use 'res', query succeeded
+	///       while (Row row = res.fetch_row()) {
+	///           // Retreived another row in the result set, can use 'row'
+	///       }
+	///   }
+	/// \endcode
+	///
+	operator private_bool_type() const
+	{
+		return data_.size() && initialized_ ? &Row::initialized_ : 0;
+	}
+
+	/// \brief Return reverse iterator pointing to first element in the
+	/// container
+	const_reverse_iterator rbegin() const { return data_.rbegin(); }
+
+	/// \brief Return reverse iterator pointing to one past the last
+	/// element in the container
+	const_reverse_iterator rend() const { return data_.rend(); }
+
+	/// \brief Get the number of fields in the row.
+	size_type size() const { return data_.size(); }
+
+	/// \brief Get a list of the values in this row
+	///
+	/// When inserted into a C++ stream, the delimiter 'd' will be used
+	/// between the items, and the quoting and escaping rules will be
+	/// set by the manipulator 'm' you choose.
+	///
+	/// \param d delimiter to use between values
+	/// \param m manipulator to use when inserting values into a stream
+	template <class Manip>
+	value_list_ba<Row, Manip> value_list(const char* d = ",",
+			Manip m = quote) const
+	{
+		return value_list_ba<Row, Manip>(*this, d, m);
+	}
+	
+	/// \brief Get a list of the values in this row
+	///
+	/// \param d delimiter to use between values
+	/// \param vb for each true item in this list, add that value to the
+	/// returned list; ignore the others
+	/// \param m manipulator to use when inserting values into a stream
+	template <class Manip>
+	value_list_b<Row, Manip> value_list(const char *d,
+			const std::vector<bool>& vb, Manip m = quote) const
+	{
+		return value_list_b<Row, Manip>(*this, vb, d, m);
+	}
+	
+	/// \brief Get a list of the values in this row
+	///
+	/// \param vb for each true item in this list, add that value to the
+	/// returned list; ignore the others
+	///
+	/// Items will be quoted and escaped when inserted into a C++ stream,
+	/// and a comma will be used as a delimiter between the items.
+	value_list_b<Row, quote_type0> value_list(
+			const std::vector<bool> &vb) const
+	{
+		return value_list_b<Row, quote_type0>(*this, vb, ",", quote);
+	}
+	
+	/// \brief Get a list of the values in this row
+	///
+	/// For each true parameter, the value in that position within the
+	/// row is added to the returned list.  When the list is inserted
+	/// into a C++ stream, the delimiter 'd' will be placed between the
+	/// items, and the manipulator 'm' used before each item.
+	template <class Manip>
+	value_list_b<Row, Manip> value_list(const char *d, Manip m,
+			bool t0, bool t1 = false, bool t2 = false, bool t3 = false,
+			bool t4 = false, bool t5 = false, bool t6 = false,
+			bool t7 = false, bool t8 = false, bool t9 = false,
+			bool ta = false, bool tb = false, bool tc = false) const
+	{
+		std::vector<bool> vb;
+		create_vector(size(), vb, t0, t1, t2, t3, t4, t5, t6,
+				t7, t8, t9, ta, tb, tc);
+		return value_list_b<Row, Manip>(*this, vb, d, m);
+	}
+	
+	/// \brief Get a list of the values in this row
+	///
+	/// For each true parameter, the value in that position within the
+	/// row is added to the returned list.  When the list is inserted
+	/// into a C++ stream, the delimiter 'd' will be placed between the
+	/// items, and items will be quoted and escaped.
+	value_list_b <Row, quote_type0>
+	value_list(const char *d, bool t0, bool t1 = false, bool t2 = false,
+			bool t3 = false, bool t4 = false, bool t5 = false,
+			bool t6 = false, bool t7 = false, bool t8 = false,
+			bool t9 = false, bool ta = false, bool tb = false,
+			bool tc = false) const
+	{
+		std::vector<bool> vb;
+		create_vector(size(), vb, t0, t1, t2, t3, t4, t5, t6,
+				t7, t8, t9, ta, tb, tc);
+		return value_list_b<Row, quote_type0>(*this, vb, d, quote);
+	}
+	
+	/// \brief Get a list of the values in this row
+	///
+	/// For each true parameter, the value in that position within the
+	/// row is added to the returned list.  When the list is inserted
+	/// into a C++ stream, the a comma will be placed between the items,
+	/// as a delimiter, and items will be quoted and escaped.
+	value_list_b<Row, quote_type0> value_list(bool t0,
+			bool t1 = false, bool t2 = false, bool t3 = false,
+			bool t4 = false, bool t5 = false, bool t6 = false,
+			bool t7 = false, bool t8 = false, bool t9 = false,
+			bool ta = false, bool tb = false, bool tc = false) const
+	{
+		std::vector<bool> vb;
+		create_vector(size(), vb, t0, t1, t2, t3, t4, t5, t6,
+				t7, t8, t9, ta, tb, tc);
+		return value_list_b<Row, quote_type0>(*this, vb, ",", quote);
+	}
+	
+	/// \brief Get a list of the values in this row
+	///
+	/// The 's' parameters name the fields that will be added to the
+	/// returned list.  When inserted into a C++ stream, the delimiter
+	/// 'd' will be placed between the items, and the manipulator 'm'
+	/// will be inserted before each item.
+	template <class Manip>
+	value_list_b<Row, Manip> value_list(const char *d, Manip m,
+			std::string s0, std::string s1 = "", std::string s2 = "",
+			std::string s3 = "", std::string s4 = "",
+			std::string s5 = "", std::string s6 = "",
+			std::string s7 = "", std::string s8 = "",
+			std::string s9 = "", std::string sa = "",
+			std::string sb = "", std::string sc = "") const
+	{
+		std::vector<bool> vb;
+		create_vector(*this, vb, s0, s1, s2, s3, s4, s5, s6, s7, s8,
+				s9, sa, sb, sc);
+		return value_list_b<Row, Manip>(*this, vb, d, m);
+	}
+	
+	/// \brief Get a list of the values in this row
+	///
+	/// The 's' parameters name the fields that will be added to the
+	/// returned list.  When inserted into a C++ stream, the delimiter
+	/// 'd' will be placed between the items, and items will be quoted
+	/// and escaped.
+	value_list_b<Row, quote_type0> value_list(
+			const char *d,
+			std::string s0, std::string s1 = "", std::string s2 = "",
+			std::string s3 = "", std::string s4 = "",
+			std::string s5 = "", std::string s6 = "",
+			std::string s7 = "", std::string s8 = "",
+			std::string s9 = "", std::string sa = "",
+			std::string sb = "", std::string sc = "") const
+	{
+		std::vector<bool> vb;
+		create_vector(*this, vb, s0, s1, s2, s3, s4, s5, s6, s7, s8,
+				s9, sa, sb, sc);
+		return value_list_b<Row, quote_type0>(*this, vb, d, quote);
+	}
+	
+	/// \brief Get a list of the values in this row
+	///
+	/// The 's' parameters name the fields that will be added to the
+	/// returned list.  When inserted into a C++ stream, a comma will be
+	/// placed between the items as a delimiter, and items will be
+	/// quoted and escaped.
+	value_list_b<Row, quote_type0> value_list(
+			std::string s0,
+			std::string s1 = "", std::string s2 = "",
+			std::string s3 = "", std::string s4 = "",
+			std::string s5 = "", std::string s6 = "",
+			std::string s7 = "", std::string s8 = "",
+			std::string s9 = "", std::string sa = "",
+			std::string sb = "", std::string sc = "") const
+	{
+		std::vector<bool> vb;
+		create_vector(*this, vb, s0, s1, s2, s3, s4, s5, s6, s7, s8,
+				s9, sa, sb, sc);
+		return value_list_b<Row, quote_type0>(*this, vb, ",", quote);
+	}
+
+private:
+	list_type data_;
+	RefCountedPointer<FieldNames> field_names_;
+	bool initialized_;
+};
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_ROW_H)

ADDED   lib/sql_buffer.cpp
Index: lib/sql_buffer.cpp
==================================================================
--- /dev/null
+++ lib/sql_buffer.cpp
@@ -0,0 +1,92 @@
+/***********************************************************************
+ sql_buffer.cpp - Implements the SQLBuffer class.
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "sql_buffer.h"
+
+#include "datetime.h"
+#include "sql_types.h"
+
+#include <string.h>
+
+namespace mysqlpp {
+
+
+SQLBuffer&
+SQLBuffer::assign(const char* data, size_type length, mysql_type_info type,
+		bool is_null)
+{
+	replace_buffer(data, length);
+	type_ = type;
+	is_null_ = is_null;
+	return *this;
+}
+
+SQLBuffer& 
+SQLBuffer::assign(const std::string& s, mysql_type_info type, bool is_null)
+{
+	replace_buffer(s.data(), s.length());
+	type_ = type;
+	is_null_ = is_null;
+	return *this;
+}
+
+bool
+SQLBuffer::quote_q() const
+{
+	if ((type_.base_type().c_type() == typeid(mysqlpp::sql_datetime)) &&
+			data_ && (length_ >= 5) && (memcmp(data_, "NOW()", 5) == 0)) {
+		// The default DATETIME value is special-cased as a call to the
+		// SQL NOW() function, which must not be quoted.
+		return false;
+	}
+	else {
+		// Normal case: we can infer the need to quote from the type.
+		return type_.quote_q();
+	}
+}
+
+void
+SQLBuffer::replace_buffer(const char* pd, size_type length)
+{
+	delete[] data_;
+	data_ = 0;
+	length_ = 0;
+
+	if (pd) {
+		// The casts for the data member are because the C type system
+		// can't distinguish initialization from modification when it
+		// happens in 2 steps like this.
+		// 
+		// We cast away const for pd in case we're on a system that uses
+		// the old definition of memcpy() with non-const 2nd parameter.
+		data_ = new char[length + 1];
+		length_ = length;
+		memcpy(const_cast<char*>(data_), const_cast<char*>(pd), length_);
+		const_cast<char*>(data_)[length_] = '\0';
+	}
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/sql_buffer.h
Index: lib/sql_buffer.h
==================================================================
--- /dev/null
+++ lib/sql_buffer.h
@@ -0,0 +1,141 @@
+/// \file sql_buffer.h
+/// \brief Declares the SQLBuffer class
+
+/***********************************************************************
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc. and
+ (c) 2007 by Jonathan Wakely.  Others may also hold copyrights on
+ code in this file.  See the CREDITS file in the top directory of
+ the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_SQL_BUFFER_H)
+#define MYSQLPP_SQL_BUFFER_H
+
+#include "refcounted.h"
+#include "type_info.h"
+
+#include <string>
+
+namespace mysqlpp {
+
+/// \brief Holds SQL data in string form plus type information for use
+/// in converting the string to compatible C++ data types.
+
+class SQLBuffer
+{
+public:
+	/// \brief Type of length values
+	typedef unsigned int size_type;
+
+	/// \brief Initialize object as a copy of a raw data buffer
+	///
+	/// Copies the string into a new buffer one byte longer than
+	/// the length value given, using that to hold a C string null
+	/// terminator, just for safety.  The length value we keep does
+	/// not include this extra byte, allowing this same mechanism
+	/// to work for both C strings and binary data.
+	SQLBuffer(const char* data, size_type length, mysql_type_info type,
+			bool is_null) : data_(), length_(), type_(type),
+			is_null_(is_null)
+			{ replace_buffer(data, length); }
+ 
+	/// \brief Initialize object as a copy of a C++ string object
+	SQLBuffer(const std::string& s, mysql_type_info type, bool is_null) :
+			data_(), length_(), type_(type), is_null_(is_null)
+	{
+		replace_buffer(s.data(), static_cast<size_type>(s.length()));
+	}
+
+	/// \brief Destructor
+	~SQLBuffer() { delete[] data_; }
+
+	/// \brief Replace contents of buffer with copy of given C string
+	SQLBuffer& assign(const char* data, size_type length,
+			mysql_type_info type = mysql_type_info::string_type,
+			bool is_null = false);
+
+	/// \brief Replace contents of buffer with copy of given C++ string
+	SQLBuffer& assign(const std::string& s,
+			mysql_type_info type = mysql_type_info::string_type,
+			bool is_null = false);
+
+	/// \brief Return pointer to raw data buffer
+	const char* data() const { return data_; }
+
+	/// \brief Returns true if we were initialized with a data type
+	/// that must be escaped when used in a SQL query
+	bool escape_q() const { return type_.escape_q(); }
+
+	/// \brief Return number of bytes in data buffer
+	///
+	/// Count does not include the trailing null we tack on to our
+	/// copy of the buffer for ease of use in C string contexts.
+	/// We do this because we can be holding binary data just as
+	/// easily as a C string.
+	size_type length() const { return length_; }
+
+	/// \brief Returns true if type of buffer's contents is string
+	bool is_string() { return type_ == mysql_type_info::string_type; }
+
+	/// \brief Return true if buffer's contents represent a SQL
+	/// null.
+	///
+	/// The buffer's actual content will probably be "NULL" or
+	/// something like it, but in the SQL data type system, a SQL
+	/// null is distinct from a plain string with value "NULL".
+	bool is_null() const { return is_null_; }
+
+	/// \brief Returns true if we were initialized with a data type
+	/// that must be quoted when used in a SQL query
+	bool quote_q() const;
+
+	/// \brief Sets the internal SQL null flag
+	void set_null() { is_null_ = true; }
+
+	/// \brief Return the SQL type of the data held in the buffer
+	const mysql_type_info& type() const { return type_; }
+
+private:
+	SQLBuffer(const SQLBuffer&);
+	SQLBuffer& operator=(const SQLBuffer&);
+
+	/// \brief Common initialization for ctors
+	void init(const char* pd, size_type len, mysql_type_info type,
+			bool is_null);
+	/// \brief Implementation detail of assign() and init()
+	void replace_buffer(const char* pd, size_type length);
+
+	const char* data_;		///< pointer to the raw data buffer
+	size_type length_;		///< bytes in buffer, without trailing null
+	mysql_type_info type_;	///< SQL type of data in the buffer
+	bool is_null_;			///< if true, string represents a SQL null
+};
+
+
+/// \brief Reference-counted version of SQLBuffer.
+///
+/// No one uses SQLBuffer directly.  It exists only for use in a
+/// RefCountedPointer wrapper.
+typedef RefCountedPointer<SQLBuffer> RefCountedBuffer;
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_SQL_BUFFER_H)
+

ADDED   lib/sql_types.h
Index: lib/sql_types.h
==================================================================
--- /dev/null
+++ lib/sql_types.h
@@ -0,0 +1,154 @@
+/// \file sql_types.h
+/// \brief Declares the closest C++ equivalent of each MySQL column type
+///
+/// The typedefs defined here are only for the "non-NULL" variants.
+/// To get nullable versions, wrap the appropriate type in the
+/// \c Null<T> template.  See null.h for more information.
+
+/***********************************************************************
+ Copyright (c) 2006-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_SQL_TYPES_H_MAIN)
+#define MYSQLPP_SQL_TYPES_H_MAIN
+
+#include "common.h"
+#include "tiny_int.h"
+
+#include <string>
+
+#if !defined(MYSQLPP_NO_STDINT_H)
+#	include <stdint.h>
+#endif
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Suppress refman documentation for these typedefs, as they're
+// system-dependent.
+
+// Define C++ integer types that are most nearly equivalent to those
+// used by the MySQL server.
+#if defined(MYSQLPP_NO_STDINT_H)
+	// Boo, we're going to have to wing it.
+	typedef tiny_int<signed char>	sql_tinyint;
+	typedef tiny_int<unsigned char>	sql_tinyint_unsigned;
+	typedef signed short			sql_smallint;
+	typedef unsigned short			sql_smallint_unsigned;
+	typedef signed int				sql_int;
+	typedef unsigned int			sql_int_unsigned;
+	typedef signed int				sql_mediumint;
+	typedef unsigned int			sql_mediumint_unsigned;
+	typedef longlong				sql_bigint;
+	typedef ulonglong				sql_bigint_unsigned;
+#else
+	// Assume a system where C99 is supported in C++ in advance of
+	// actual standardization, so we can do this portably.
+	typedef tiny_int<int8_t>		sql_tinyint;
+	typedef tiny_int<uint8_t>		sql_tinyint_unsigned;
+	typedef int16_t					sql_smallint;
+	typedef uint16_t				sql_smallint_unsigned;
+	typedef int32_t					sql_int;
+	typedef uint32_t				sql_int_unsigned;
+	typedef int32_t					sql_mediumint;
+	typedef uint32_t				sql_mediumint_unsigned;
+	typedef int64_t					sql_bigint;
+	typedef uint64_t				sql_bigint_unsigned;
+#endif
+
+// Now define typedef equivalencies for the other standard MySQL
+// data types.  There aren't serious portability issues here.
+typedef float					sql_float;
+typedef double					sql_double;
+typedef double					sql_decimal;
+typedef std::string				sql_enum;
+typedef std::string				sql_char;
+typedef std::string				sql_varchar;
+typedef std::string				sql_tinytext;
+typedef std::string				sql_text;
+typedef std::string				sql_mediumtext;
+typedef std::string				sql_longtext;
+
+// Aliases to match the rules MySQL uses in translating data types
+// from other database servers into its own type system.  From:
+// http://dev.mysql.com/doc/refman/5.0/en/other-vendor-data-types.html
+typedef sql_tinyint				sql_bool;
+typedef sql_tinyint				sql_boolean;
+typedef sql_varchar				sql_character_varying;
+typedef sql_decimal				sql_fixed;
+typedef sql_float				sql_float4;
+typedef sql_double				sql_float8;
+typedef sql_tinyint				sql_int1;
+typedef sql_smallint			sql_int2;
+typedef sql_mediumint			sql_int3;
+typedef sql_int					sql_int4;
+typedef sql_bigint				sql_int8;
+typedef sql_mediumtext			sql_long_varchar;
+typedef sql_mediumtext			sql_long;
+typedef sql_mediumint			sql_middleint;
+typedef sql_decimal				sql_numeric;
+#endif // !defined(DOXYGEN_IGNORE)
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_SQL_TYPES_H_MAIN)
+
+
+// The following sections are treated separately to avoid making the
+// #include tree too dense: if mystring.h (for example) is not yet
+// #included, no sense pulling it in to define all the typedefs based
+// on String.  The separate #include guards for each section allow
+// this file to be #included as many times as necessary to build up the
+// full typedef set.  This trickery is necessary because sql_types.h
+// is needed in a few places within MySQL++, but we can't (and don't)
+// depend on having the full set of typedefs.  mysql++.h #includes this
+// at a late stage, ensuring that end-user code does see the full set.
+#if defined(MYSQLPP_MYSTRING_H) && !defined(MYSQLPP_SQL_TYPES_H_MYSTRING) && !defined(DOXYGEN_IGNORE)
+#	define MYSQLPP_SQL_TYPES_H_MYSTRING
+	namespace mysqlpp {
+		typedef String			sql_blob;
+		typedef String			sql_tinyblob;
+		typedef String			sql_mediumblob;
+		typedef String			sql_longblob;
+		typedef sql_mediumblob	sql_long_varbinary;
+	} // end namespace mysqlpp
+#endif
+
+
+#if defined(MYSQLPP_DATETIME_H) && !defined(MYSQLPP_SQL_TYPES_H_DATETIME) && !defined(DOXYGEN_IGNORE)
+#	define MYSQLPP_SQL_TYPES_H_DATETIME
+	namespace mysqlpp {
+		typedef Date			sql_date;
+		typedef Time			sql_time;
+		typedef DateTime		sql_timestamp;
+		typedef DateTime		sql_datetime;
+	} // end namespace mysqlpp
+#endif
+
+
+#if defined(MYSQLPP_MYSET_H) && !defined(MYSQLPP_SQL_TYPES_H_SET) && !defined(DOXYGEN_IGNORE)
+#	define MYSQLPP_SQL_TYPES_H_SET
+	namespace mysqlpp {
+		typedef Set<>				sql_set;
+	} // end namespace mysqlpp
+#endif
+

ADDED   lib/ssqls.h
Index: lib/ssqls.h
==================================================================
--- /dev/null
+++ lib/ssqls.h
@@ -0,0 +1,23965 @@
+
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// This file is generated by the Perl script ssqls.pl.  Do not modify
+// it directly.  Change the script instead.
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+#if !defined(MYSQLPP_SSQLS_H)
+#define MYSQLPP_SSQLS_H
+
+#include "noexceptions.h"
+#include "sql_types.h"
+
+#if !defined(MYSQLPP_SSQLS_COMPATIBLE)
+#	error Your compiler is not compatible with the SSQLS feature!
+#endif
+
+#include <string>
+
+#include <math.h>
+
+// Smallest difference between two floating point numbers recognized
+// in making comparisons.  If the absolute delta is under this
+// threshold, the two values are considered equal.  You can either
+// override this permanently by changing ssqls.pl, or you can do it
+// on a case-by-case basis at compile time by defining this to another
+// value before #including this header.
+#if !defined(MYSQLPP_FP_MIN_DELTA)
+#	define MYSQLPP_FP_MIN_DELTA 0.00001
+#endif
+
+namespace mysqlpp {
+
+enum sql_dummy_type { sql_dummy };
+
+#ifdef MYSQLPP_SSQLS_NO_STATICS
+#	define MYSQLPP_SSQLS_CONDITIONAL_STATICS(...)
+#else
+#	define MYSQLPP_SSQLS_CONDITIONAL_STATICS(...) __VA_ARGS__
+#endif
+
+
+inline int sql_cmp(const Date& a, const Date& b)
+{
+	return a.compare(b);
+}
+
+inline int sql_cmp(const DateTime& a, const DateTime& b)
+{
+	return a.compare(b);
+}
+
+inline int sql_cmp(const Time& a, const Time& b)
+{
+	return a.compare(b);
+}
+
+inline int sql_cmp(const String& a, const String& b)
+{
+	return a.compare(b);
+}
+
+inline int sql_cmp(const std::string& a, const std::string& b)
+{
+	return a.compare(b);
+}
+
+inline int sql_cmp(signed char a, signed char b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(unsigned char a, unsigned char b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(sql_tinyint a, sql_tinyint b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(sql_tinyint_unsigned a, sql_tinyint_unsigned b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(signed int a, signed int b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(unsigned a, unsigned b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(signed short a, signed short b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(unsigned short a, unsigned short b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(signed long a, signed long b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(unsigned long a, unsigned long b)
+{
+	return a - b;
+}
+
+inline int sql_cmp(longlong a, longlong b) 
+{
+	if (a == b) return 0;
+	if (a <  b) return -1;
+	return 1;
+}
+
+inline int sql_cmp(ulonglong a, ulonglong b) 
+{
+	if (a == b) return 0;
+	if (a <  b) return -1;
+	return 1;
+}
+
+inline int sql_cmp(double a, double b) 
+{
+	if (fabs(a - b) < MYSQLPP_FP_MIN_DELTA) return 0;
+	if (a <  b) return -1;
+	return 1;
+}
+
+inline int sql_cmp(float a, float b) 
+{
+	if (fabs(a - b) < MYSQLPP_FP_MIN_DELTA) return 0;
+	if (a <  b) return -1;
+	return 1;
+}
+
+template <typename T>
+inline int sql_cmp(const mysqlpp::Null<T>& a, const mysqlpp::Null<T>& b) 
+{
+	if (a == b) return 0;
+	if (a <  b) return -1;
+	return 1;
+}
+
+
+// ---------------------------------------------------
+//                Begin Mandatory Compare 
+// ---------------------------------------------------
+
+#define sql_compare_define(NAME) \
+    bool operator == (const NAME &other) const \
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) == 0;} \
+    bool operator != (const NAME &other) const \
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) != 0;} \
+    bool operator > (const NAME &other) const \
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) >  0;} \
+    bool operator < (const NAME &other) const \
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) <  0;} \
+    bool operator >= (const NAME &other) const \
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) >= 0;} \
+    bool operator <= (const NAME &other) const \
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) <= 0;} \
+    int cmp (const NAME &other) const \
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other);} \
+    int compare (const NAME &other) const \
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other);}
+
+#define sql_compare_define_0(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25)
+
+#define sql_construct_define_0(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25)
+
+#define sql_COMPARE__0(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25)
+
+#define sql_compare_type_def_0(NAME, WHAT, NUM) \
+  sql_compare_type_def_##NUM(NAME, WHAT, NUM)
+
+#define sql_compare_type_defe_0(NAME, WHAT, NUM) \
+  sql_compare_type_defe_##NUM(NAME, WHAT, NUM)
+
+// ---------------------------------------------------
+//                 End Mandatory Compare 
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                   Begin Compare 1
+// ---------------------------------------------------
+
+#define sql_compare_define_1(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1) : C1 (p1), table_override_(0) {} \
+  void set(const T1 &p1) { \
+	table_override_ = 0; \
+    C1 = p1;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_1(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1) { \
+	table_override_ = 0; \
+    C1 = p1;\
+ \
+  } \
+  NAME(const T1 &p1) : C1 (p1), table_override_(0) {}
+
+#define sql_compare_type_def_1(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true)
+
+#define sql_compare_type_defe_1(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true)
+
+#define sql_COMPARE__1(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    return mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    return mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 1
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 2
+// ---------------------------------------------------
+
+#define sql_compare_define_2(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2) : C1 (p1), C2 (p2), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_2(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2) : C1 (p1), C2 (p2), table_override_(0) {}
+
+#define sql_compare_type_def_2(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true)
+
+#define sql_compare_type_defe_2(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true)
+
+#define sql_COMPARE__2(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 2
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 3
+// ---------------------------------------------------
+
+#define sql_compare_define_3(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3) : C1 (p1), C2 (p2), C3 (p3), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_3(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3) : C1 (p1), C2 (p2), C3 (p3), table_override_(0) {}
+
+#define sql_compare_type_def_3(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true)
+
+#define sql_compare_type_defe_3(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true)
+
+#define sql_COMPARE__3(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 3
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 4
+// ---------------------------------------------------
+
+#define sql_compare_define_4(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_4(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), table_override_(0) {}
+
+#define sql_compare_type_def_4(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true)
+
+#define sql_compare_type_defe_4(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true)
+
+#define sql_COMPARE__4(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 4
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 5
+// ---------------------------------------------------
+
+#define sql_compare_define_5(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_5(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), table_override_(0) {}
+
+#define sql_compare_type_def_5(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true)
+
+#define sql_compare_type_defe_5(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true)
+
+#define sql_COMPARE__5(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 5
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 6
+// ---------------------------------------------------
+
+#define sql_compare_define_6(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_6(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), table_override_(0) {}
+
+#define sql_compare_type_def_6(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_6(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true)
+
+#define sql_COMPARE__6(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 6
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 7
+// ---------------------------------------------------
+
+#define sql_compare_define_7(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_7(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), table_override_(0) {}
+
+#define sql_compare_type_def_7(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_7(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__7(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 7
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 8
+// ---------------------------------------------------
+
+#define sql_compare_define_8(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_8(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), table_override_(0) {}
+
+#define sql_compare_type_def_8(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_8(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__8(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 8
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 9
+// ---------------------------------------------------
+
+#define sql_compare_define_9(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_9(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), table_override_(0) {}
+
+#define sql_compare_type_def_9(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_9(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__9(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 9
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 10
+// ---------------------------------------------------
+
+#define sql_compare_define_10(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_10(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), table_override_(0) {}
+
+#define sql_compare_type_def_10(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_10(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__10(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 10
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 11
+// ---------------------------------------------------
+
+#define sql_compare_define_11(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_11(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), table_override_(0) {}
+
+#define sql_compare_type_def_11(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_11(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__11(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 11
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 12
+// ---------------------------------------------------
+
+#define sql_compare_define_12(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_12(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), table_override_(0) {}
+
+#define sql_compare_type_def_12(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_12(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__12(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 12
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 13
+// ---------------------------------------------------
+
+#define sql_compare_define_13(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_13(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), table_override_(0) {}
+
+#define sql_compare_type_def_13(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_13(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__13(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 13
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 14
+// ---------------------------------------------------
+
+#define sql_compare_define_14(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_14(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), table_override_(0) {}
+
+#define sql_compare_type_def_14(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_14(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__14(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 14
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 15
+// ---------------------------------------------------
+
+#define sql_compare_define_15(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_15(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), table_override_(0) {}
+
+#define sql_compare_type_def_15(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_15(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__15(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 15
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 16
+// ---------------------------------------------------
+
+#define sql_compare_define_16(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_16(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), table_override_(0) {}
+
+#define sql_compare_type_def_16(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_16(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__16(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 16
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 17
+// ---------------------------------------------------
+
+#define sql_compare_define_17(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_17(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), table_override_(0) {}
+
+#define sql_compare_type_def_17(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_17(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__17(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 17
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 18
+// ---------------------------------------------------
+
+#define sql_compare_define_18(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_18(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), table_override_(0) {}
+
+#define sql_compare_type_def_18(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_18(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__18(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 18
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 19
+// ---------------------------------------------------
+
+#define sql_compare_define_19(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_19(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), table_override_(0) {}
+
+#define sql_compare_type_def_19(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_19(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__19(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 19
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 20
+// ---------------------------------------------------
+
+#define sql_compare_define_20(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_20(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), table_override_(0) {}
+
+#define sql_compare_type_def_20(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_20(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__20(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 20
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 21
+// ---------------------------------------------------
+
+#define sql_compare_define_21(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_21(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), table_override_(0) {}
+
+#define sql_compare_type_def_21(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_21(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__21(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 21
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 22
+// ---------------------------------------------------
+
+#define sql_compare_define_22(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), C22 (p22), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+    C22 = p22;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_22(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+    C22 = p22;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), C22 (p22), table_override_(0) {}
+
+#define sql_compare_type_def_22(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_22(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__22(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C22 , y.C22 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C22 , y.C22 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 22
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 23
+// ---------------------------------------------------
+
+#define sql_compare_define_23(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), C22 (p22), C23 (p23), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+    C22 = p22;\
+    C23 = p23;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_23(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+    C22 = p22;\
+    C23 = p23;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), C22 (p22), C23 (p23), table_override_(0) {}
+
+#define sql_compare_type_def_23(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_23(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__23(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C22 , y.C22 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C23 , y.C23 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C22 , y.C22 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C23 , y.C23 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 23
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 24
+// ---------------------------------------------------
+
+#define sql_compare_define_24(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23, const T24 &p24) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), C22 (p22), C23 (p23), C24 (p24), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23, const T24 &p24) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+    C22 = p22;\
+    C23 = p23;\
+    C24 = p24;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_24(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23, const T24 &p24) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+    C22 = p22;\
+    C23 = p23;\
+    C24 = p24;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23, const T24 &p24) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), C22 (p22), C23 (p23), C24 (p24), table_override_(0) {}
+
+#define sql_compare_type_def_24(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_24(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__24(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C22 , y.C22 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C23 , y.C23 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C24 , y.C24 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C22 , y.C22 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C23 , y.C23 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C24 , y.C24 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 24
+// ---------------------------------------------------
+
+
+// ---------------------------------------------------
+//                   Begin Compare 25
+// ---------------------------------------------------
+
+#define sql_compare_define_25(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23, const T24 &p24, const T25 &p25) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), C22 (p22), C23 (p23), C24 (p24), C25 (p25), table_override_(0) {} \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23, const T24 &p24, const T25 &p25) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+    C22 = p22;\
+    C23 = p23;\
+    C24 = p24;\
+    C25 = p25;\
+ \
+  } \
+  sql_compare_define(NAME)
+
+#define sql_construct_define_25(NAME, T1, C1, T2, C2, T3, C3, T4, C4, T5, C5, T6, C6, T7, C7, T8, C8, T9, C9, T10, C10, T11, C11, T12, C12, T13, C13, T14, C14, T15, C15, T16, C16, T17, C17, T18, C18, T19, C19, T20, C20, T21, C21, T22, C22, T23, C23, T24, C24, T25, C25) \
+  void set(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23, const T24 &p24, const T25 &p25) { \
+	table_override_ = 0; \
+    C1 = p1;\
+    C2 = p2;\
+    C3 = p3;\
+    C4 = p4;\
+    C5 = p5;\
+    C6 = p6;\
+    C7 = p7;\
+    C8 = p8;\
+    C9 = p9;\
+    C10 = p10;\
+    C11 = p11;\
+    C12 = p12;\
+    C13 = p13;\
+    C14 = p14;\
+    C15 = p15;\
+    C16 = p16;\
+    C17 = p17;\
+    C18 = p18;\
+    C19 = p19;\
+    C20 = p20;\
+    C21 = p21;\
+    C22 = p22;\
+    C23 = p23;\
+    C24 = p24;\
+    C25 = p25;\
+ \
+  } \
+  NAME(const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9, const T10 &p10, const T11 &p11, const T12 &p12, const T13 &p13, const T14 &p14, const T15 &p15, const T16 &p16, const T17 &p17, const T18 &p18, const T19 &p19, const T20 &p20, const T21 &p21, const T22 &p22, const T23 &p23, const T24 &p24, const T25 &p25) : C1 (p1), C2 (p2), C3 (p3), C4 (p4), C5 (p5), C6 (p6), C7 (p7), C8 (p8), C9 (p9), C10 (p10), C11 (p11), C12 (p12), C13 (p13), C14 (p14), C15 (p15), C16 (p16), C17 (p17), C18 (p18), C19 (p19), C20 (p20), C21 (p21), C22 (p22), C23 (p23), C24 (p24), C25 (p25), table_override_(0) {}
+
+#define sql_compare_type_def_25(NAME, WHAT, NUM) \
+  return WHAT##_list(d, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_compare_type_defe_25(NAME, WHAT, NUM) \
+  return WHAT##_list(d, c, m, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true)
+
+#define sql_COMPARE__25(NAME, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25) \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C22 , y.C22 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C23 , y.C23 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C24 , y.C24 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C25 , y.C25 ); \
+  } \
+  template <mysqlpp::sql_dummy_type dummy> \
+  int compare (const NAME &x, const NAME &y) { \
+    int cmp; \
+    cmp = mysqlpp::sql_cmp(x.C1 , y.C1 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C2 , y.C2 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C3 , y.C3 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C4 , y.C4 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C5 , y.C5 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C6 , y.C6 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C7 , y.C7 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C8 , y.C8 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C9 , y.C9 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C10 , y.C10 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C11 , y.C11 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C12 , y.C12 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C13 , y.C13 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C14 , y.C14 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C15 , y.C15 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C16 , y.C16 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C17 , y.C17 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C18 , y.C18 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C19 , y.C19 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C20 , y.C20 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C21 , y.C21 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C22 , y.C22 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C23 , y.C23 ); \
+    if (cmp) return cmp; \
+    cmp = mysqlpp::sql_cmp(x.C24 , y.C24 ); \
+    if (cmp) return cmp; \
+    return mysqlpp::sql_cmp(x.C25 , y.C25 ); \
+  }
+
+// ---------------------------------------------------
+//                   End Compare 25
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 1
+// ---------------------------------------------------
+#define sql_create_complete_1(NAME, CMP, CONTR, T1, I1, N1) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1) const {\
+      return value_list(",", mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1) const {\
+      return value_list(",", mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1) const {\
+      return value_list(d, mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1) const {\
+      return value_list(d, mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1) const {\
+      return field_list(",", mysqlpp::do_nothing, i1);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1) const {\
+      return field_list(",", mysqlpp::do_nothing, i1);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1) const {\
+      return field_list(d, mysqlpp::do_nothing, i1);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1) const {\
+      return field_list(d, mysqlpp::do_nothing, i1);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1) const {\
+      return equal_list(d, c, mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1) const {\
+      return equal_list(d, c, mysqlpp::quote, i1);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(1, false);\
+    if (i1) (*include)[0]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(1, false); \
+    (*include)[i1]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(1, false); \
+    if (i1) (*include)[0]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(1, false); \
+    (*include)[i1]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(1, false); \
+    if (i1) (*include)[0]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(1, false); \
+    (*include)[i1]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_1(NAME, CMP, CONTR, T1, I1) \
+  sql_create_complete_1(NAME, CMP, CONTR, T1, I1, #I1) \
+
+// ---------------------------------------------------
+//                  End Create 1
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 2
+// ---------------------------------------------------
+#define sql_create_complete_2(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(2, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(2, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(2, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(2, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(2, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(2, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_2(NAME, CMP, CONTR, T1, I1, T2, I2) \
+  sql_create_complete_2(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2) \
+
+// ---------------------------------------------------
+//                  End Create 2
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 3
+// ---------------------------------------------------
+#define sql_create_complete_3(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(3, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(3, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(3, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(3, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(3, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(3, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_3(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3) \
+  sql_create_complete_3(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3) \
+
+// ---------------------------------------------------
+//                  End Create 3
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 4
+// ---------------------------------------------------
+#define sql_create_complete_4(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(4, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(4, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(4, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(4, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(4, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(4, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_4(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4) \
+  sql_create_complete_4(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4) \
+
+// ---------------------------------------------------
+//                  End Create 4
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 5
+// ---------------------------------------------------
+#define sql_create_complete_5(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(5, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(5, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(5, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(5, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(5, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(5, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_5(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5) \
+  sql_create_complete_5(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5) \
+
+// ---------------------------------------------------
+//                  End Create 5
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 6
+// ---------------------------------------------------
+#define sql_create_complete_6(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(6, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(6, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(6, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(6, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(6, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(6, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_6(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6) \
+  sql_create_complete_6(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6) \
+
+// ---------------------------------------------------
+//                  End Create 6
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 7
+// ---------------------------------------------------
+#define sql_create_complete_7(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(7, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(7, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(7, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(7, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(7, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(7, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_7(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7) \
+  sql_create_complete_7(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7) \
+
+// ---------------------------------------------------
+//                  End Create 7
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 8
+// ---------------------------------------------------
+#define sql_create_complete_8(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(8, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(8, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(8, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(8, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(8, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(8, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_8(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8) \
+  sql_create_complete_8(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8) \
+
+// ---------------------------------------------------
+//                  End Create 8
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 9
+// ---------------------------------------------------
+#define sql_create_complete_9(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(9, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(9, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(9, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(9, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(9, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(9, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_9(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9) \
+  sql_create_complete_9(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9) \
+
+// ---------------------------------------------------
+//                  End Create 9
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 10
+// ---------------------------------------------------
+#define sql_create_complete_10(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(10, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(10, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(10, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(10, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(10, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(10, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_10(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10) \
+  sql_create_complete_10(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10) \
+
+// ---------------------------------------------------
+//                  End Create 10
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 11
+// ---------------------------------------------------
+#define sql_create_complete_11(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(11, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(11, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(11, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(11, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(11, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(11, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_11(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11) \
+  sql_create_complete_11(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11) \
+
+// ---------------------------------------------------
+//                  End Create 11
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 12
+// ---------------------------------------------------
+#define sql_create_complete_12(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(12, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(12, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(12, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(12, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(12, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(12, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_12(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12) \
+  sql_create_complete_12(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12) \
+
+// ---------------------------------------------------
+//                  End Create 12
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 13
+// ---------------------------------------------------
+#define sql_create_complete_13(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(13, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(13, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(13, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(13, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(13, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(13, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_13(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13) \
+  sql_create_complete_13(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13) \
+
+// ---------------------------------------------------
+//                  End Create 13
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 14
+// ---------------------------------------------------
+#define sql_create_complete_14(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(14, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(14, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(14, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(14, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(14, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(14, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_14(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14) \
+  sql_create_complete_14(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14) \
+
+// ---------------------------------------------------
+//                  End Create 14
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 15
+// ---------------------------------------------------
+#define sql_create_complete_15(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(15, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(15, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(15, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(15, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(15, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(15, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_15(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15) \
+  sql_create_complete_15(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15) \
+
+// ---------------------------------------------------
+//                  End Create 15
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 16
+// ---------------------------------------------------
+#define sql_create_complete_16(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(16, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(16, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(16, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(16, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(16, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(16, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_16(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16) \
+  sql_create_complete_16(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16) \
+
+// ---------------------------------------------------
+//                  End Create 16
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 17
+// ---------------------------------------------------
+#define sql_create_complete_17(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(17, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(17, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(17, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(17, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(17, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(17, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, 0, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_17(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17) \
+  sql_create_complete_17(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17) \
+
+// ---------------------------------------------------
+//                  End Create 17
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 18
+// ---------------------------------------------------
+#define sql_create_complete_18(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17, T18, I18, N18) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17,\
+    NAME##_##I18 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17;\
+    T18 I18; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 ,\
+    N18 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(18, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(18, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(18, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(18, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(18, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(18, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.manip << obj.obj->I18; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16] << obj.delim;\
+    s << obj.manip << obj.obj->names[17]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I18;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[17];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+    s->I18 = row[N18].conv(T18());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, 0, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_18(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18) \
+  sql_create_complete_18(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17, T18, I18, #I18) \
+
+// ---------------------------------------------------
+//                  End Create 18
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 19
+// ---------------------------------------------------
+#define sql_create_complete_19(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17, T18, I18, N18, T19, I19, N19) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17,\
+    NAME##_##I18,\
+    NAME##_##I19 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17;\
+    T18 I18;\
+    T19 I19; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 ,\
+    N18 ,\
+    N19 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(19, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(19, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(19, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(19, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(19, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(19, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.manip << obj.obj->I19; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16] << obj.delim;\
+    s << obj.manip << obj.obj->names[17] << obj.delim;\
+    s << obj.manip << obj.obj->names[18]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I19;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[17];\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[18];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+    s->I18 = row[N18].conv(T18());\
+    s->I19 = row[N19].conv(T19());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, 0, 0, 0, 0, 0, 0 )
+
+#define sql_create_19(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19) \
+  sql_create_complete_19(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17, T18, I18, #I18, T19, I19, #I19) \
+
+// ---------------------------------------------------
+//                  End Create 19
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 20
+// ---------------------------------------------------
+#define sql_create_complete_20(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17, T18, I18, N18, T19, I19, N19, T20, I20, N20) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17,\
+    NAME##_##I18,\
+    NAME##_##I19,\
+    NAME##_##I20 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17;\
+    T18 I18;\
+    T19 I19;\
+    T20 I20; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 ,\
+    N18 ,\
+    N19 ,\
+    N20 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(20, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(20, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(20, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(20, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(20, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(20, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.manip << obj.obj->I20; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16] << obj.delim;\
+    s << obj.manip << obj.obj->names[17] << obj.delim;\
+    s << obj.manip << obj.obj->names[18] << obj.delim;\
+    s << obj.manip << obj.obj->names[19]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I20;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[17];\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[18];\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[19];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+    s->I18 = row[N18].conv(T18());\
+    s->I19 = row[N19].conv(T19());\
+    s->I20 = row[N20].conv(T20());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, 0, 0, 0, 0, 0 )
+
+#define sql_create_20(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20) \
+  sql_create_complete_20(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17, T18, I18, #I18, T19, I19, #I19, T20, I20, #I20) \
+
+// ---------------------------------------------------
+//                  End Create 20
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 21
+// ---------------------------------------------------
+#define sql_create_complete_21(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17, T18, I18, N18, T19, I19, N19, T20, I20, N20, T21, I21, N21) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17,\
+    NAME##_##I18,\
+    NAME##_##I19,\
+    NAME##_##I20,\
+    NAME##_##I21 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17;\
+    T18 I18;\
+    T19 I19;\
+    T20 I20;\
+    T21 I21; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, 0, 0, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, 0, 0, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 ,\
+    N18 ,\
+    N19 ,\
+    N20 ,\
+    N21 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(21, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(21, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(21, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(21, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(21, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(21, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.manip << obj.obj->I21; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16] << obj.delim;\
+    s << obj.manip << obj.obj->names[17] << obj.delim;\
+    s << obj.manip << obj.obj->names[18] << obj.delim;\
+    s << obj.manip << obj.obj->names[19] << obj.delim;\
+    s << obj.manip << obj.obj->names[20]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I21;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[17];\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[18];\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[19];\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[20];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+    s->I18 = row[N18].conv(T18());\
+    s->I19 = row[N19].conv(T19());\
+    s->I20 = row[N20].conv(T20());\
+    s->I21 = row[N21].conv(T21());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, 0, 0, 0, 0 )
+
+#define sql_create_21(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21) \
+  sql_create_complete_21(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17, T18, I18, #I18, T19, I19, #I19, T20, I20, #I20, T21, I21, #I21) \
+
+// ---------------------------------------------------
+//                  End Create 21
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 22
+// ---------------------------------------------------
+#define sql_create_complete_22(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17, T18, I18, N18, T19, I19, N19, T20, I20, N20, T21, I21, N21, T22, I22, N22) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17,\
+    NAME##_##I18,\
+    NAME##_##I19,\
+    NAME##_##I20,\
+    NAME##_##I21,\
+    NAME##_##I22 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17;\
+    T18 I18;\
+    T19 I19;\
+    T20 I20;\
+    T21 I21;\
+    T22 I22; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, 0, 0, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, 0, 0, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 ,\
+    N18 ,\
+    N19 ,\
+    N20 ,\
+    N21 ,\
+    N22 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(22, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(22, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(22, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(22, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(22, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(22, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.manip << obj.obj->I21 << obj.delim;\
+    s << obj.manip << obj.obj->I22; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16] << obj.delim;\
+    s << obj.manip << obj.obj->names[17] << obj.delim;\
+    s << obj.manip << obj.obj->names[18] << obj.delim;\
+    s << obj.manip << obj.obj->names[19] << obj.delim;\
+    s << obj.manip << obj.obj->names[20] << obj.delim;\
+    s << obj.manip << obj.obj->names[21]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21 << obj.delim;\
+    s << obj.obj->names[21] << obj.comp << obj.manip << obj.obj->I22; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I21;\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I22;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[17];\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[18];\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[19];\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[20];\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[21];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21;\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[21] << obj.comp << obj.manip << obj.obj->I22;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+    s->I18 = row[N18].conv(T18());\
+    s->I19 = row[N19].conv(T19());\
+    s->I20 = row[N20].conv(T20());\
+    s->I21 = row[N21].conv(T21());\
+    s->I22 = row[N22].conv(T22());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, 0, 0, 0 )
+
+#define sql_create_22(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22) \
+  sql_create_complete_22(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17, T18, I18, #I18, T19, I19, #I19, T20, I20, #I20, T21, I21, #I21, T22, I22, #I22) \
+
+// ---------------------------------------------------
+//                  End Create 22
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 23
+// ---------------------------------------------------
+#define sql_create_complete_23(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17, T18, I18, N18, T19, I19, N19, T20, I20, N20, T21, I21, N21, T22, I22, N22, T23, I23, N23) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17,\
+    NAME##_##I18,\
+    NAME##_##I19,\
+    NAME##_##I20,\
+    NAME##_##I21,\
+    NAME##_##I22,\
+    NAME##_##I23 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17;\
+    T18 I18;\
+    T19 I19;\
+    T20 I20;\
+    T21 I21;\
+    T22 I22;\
+    T23 I23; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23, 0, 0, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23, 0, 0, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 ,\
+    N18 ,\
+    N19 ,\
+    N20 ,\
+    N21 ,\
+    N22 ,\
+    N23 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(23, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(23, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(23, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(23, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(23, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(23, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.manip << obj.obj->I21 << obj.delim;\
+    s << obj.manip << obj.obj->I22 << obj.delim;\
+    s << obj.manip << obj.obj->I23; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16] << obj.delim;\
+    s << obj.manip << obj.obj->names[17] << obj.delim;\
+    s << obj.manip << obj.obj->names[18] << obj.delim;\
+    s << obj.manip << obj.obj->names[19] << obj.delim;\
+    s << obj.manip << obj.obj->names[20] << obj.delim;\
+    s << obj.manip << obj.obj->names[21] << obj.delim;\
+    s << obj.manip << obj.obj->names[22]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21 << obj.delim;\
+    s << obj.obj->names[21] << obj.comp << obj.manip << obj.obj->I22 << obj.delim;\
+    s << obj.obj->names[22] << obj.comp << obj.manip << obj.obj->I23; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I21;\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I22;\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I23;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[17];\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[18];\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[19];\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[20];\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[21];\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[22];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21;\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[21] << obj.comp << obj.manip << obj.obj->I22;\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[22] << obj.comp << obj.manip << obj.obj->I23;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+    s->I18 = row[N18].conv(T18());\
+    s->I19 = row[N19].conv(T19());\
+    s->I20 = row[N20].conv(T20());\
+    s->I21 = row[N21].conv(T21());\
+    s->I22 = row[N22].conv(T22());\
+    s->I23 = row[N23].conv(T23());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, 0, 0 )
+
+#define sql_create_23(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23) \
+  sql_create_complete_23(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17, T18, I18, #I18, T19, I19, #I19, T20, I20, #I20, T21, I21, #I21, T22, I22, #I22, T23, I23, #I23) \
+
+// ---------------------------------------------------
+//                  End Create 23
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 24
+// ---------------------------------------------------
+#define sql_create_complete_24(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17, T18, I18, N18, T19, I19, N19, T20, I20, N20, T21, I21, N21, T22, I22, N22, T23, I23, N23, T24, I24, N24) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17,\
+    NAME##_##I18,\
+    NAME##_##I19,\
+    NAME##_##I20,\
+    NAME##_##I21,\
+    NAME##_##I22,\
+    NAME##_##I23,\
+    NAME##_##I24 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17;\
+    T18 I18;\
+    T19 I19;\
+    T20 I20;\
+    T21 I21;\
+    T22 I22;\
+    T23 I23;\
+    T24 I24; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23, T24, I24, 0, 0)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23, T24, I24, 0, 0)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 ,\
+    N18 ,\
+    N19 ,\
+    N20 ,\
+    N21 ,\
+    N22 ,\
+    N23 ,\
+    N24 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(24, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+    if (i24) (*include)[23]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(24, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+    if (i24 == NAME##_NULL) return;\
+    (*include)[i24]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(24, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+    if (i24) (*include)[23]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(24, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+    if (i24 == NAME##_NULL) return;\
+    (*include)[i24]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(24, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+    if (i24) (*include)[23]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(24, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+    if (i24 == NAME##_NULL) return;\
+    (*include)[i24]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.manip << obj.obj->I21 << obj.delim;\
+    s << obj.manip << obj.obj->I22 << obj.delim;\
+    s << obj.manip << obj.obj->I23 << obj.delim;\
+    s << obj.manip << obj.obj->I24; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16] << obj.delim;\
+    s << obj.manip << obj.obj->names[17] << obj.delim;\
+    s << obj.manip << obj.obj->names[18] << obj.delim;\
+    s << obj.manip << obj.obj->names[19] << obj.delim;\
+    s << obj.manip << obj.obj->names[20] << obj.delim;\
+    s << obj.manip << obj.obj->names[21] << obj.delim;\
+    s << obj.manip << obj.obj->names[22] << obj.delim;\
+    s << obj.manip << obj.obj->names[23]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21 << obj.delim;\
+    s << obj.obj->names[21] << obj.comp << obj.manip << obj.obj->I22 << obj.delim;\
+    s << obj.obj->names[22] << obj.comp << obj.manip << obj.obj->I23 << obj.delim;\
+    s << obj.obj->names[23] << obj.comp << obj.manip << obj.obj->I24; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I21;\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I22;\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I23;\
+      before = true; \
+     } \
+    if ((*obj.include)[23]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I24;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[17];\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[18];\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[19];\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[20];\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[21];\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[22];\
+      before = true; \
+     } \
+    if ((*obj.include)[23]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[23];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21;\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[21] << obj.comp << obj.manip << obj.obj->I22;\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[22] << obj.comp << obj.manip << obj.obj->I23;\
+      before = true; \
+     } \
+    if ((*obj.include)[23]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[23] << obj.comp << obj.manip << obj.obj->I24;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+    s->I18 = row[N18].conv(T18());\
+    s->I19 = row[N19].conv(T19());\
+    s->I20 = row[N20].conv(T20());\
+    s->I21 = row[N21].conv(T21());\
+    s->I22 = row[N22].conv(T22());\
+    s->I23 = row[N23].conv(T23());\
+    s->I24 = row[N24].conv(T24());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, 0 )
+
+#define sql_create_24(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23, T24, I24) \
+  sql_create_complete_24(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17, T18, I18, #I18, T19, I19, #I19, T20, I20, #I20, T21, I21, #I21, T22, I22, #I22, T23, I23, #I23, T24, I24, #I24) \
+
+// ---------------------------------------------------
+//                  End Create 24
+// ---------------------------------------------------
+
+// ---------------------------------------------------
+//                  Begin Create 25
+// ---------------------------------------------------
+#define sql_create_complete_25(NAME, CMP, CONTR, T1, I1, N1, T2, I2, N2, T3, I3, N3, T4, I4, N4, T5, I5, N5, T6, I6, N6, T7, I7, N7, T8, I8, N8, T9, I9, N9, T10, I10, N10, T11, I11, N11, T12, I12, N12, T13, I13, N13, T14, I14, N14, T15, I15, N15, T16, I16, N16, T17, I17, N17, T18, I18, N18, T19, I19, N19, T20, I20, N20, T21, I21, N21, T22, I22, N22, T23, I23, N23, T24, I24, N24, T25, I25, N25) \
+  struct NAME; \
+  enum NAME##_enum { \
+    NAME##_##I1,\
+    NAME##_##I2,\
+    NAME##_##I3,\
+    NAME##_##I4,\
+    NAME##_##I5,\
+    NAME##_##I6,\
+    NAME##_##I7,\
+    NAME##_##I8,\
+    NAME##_##I9,\
+    NAME##_##I10,\
+    NAME##_##I11,\
+    NAME##_##I12,\
+    NAME##_##I13,\
+    NAME##_##I14,\
+    NAME##_##I15,\
+    NAME##_##I16,\
+    NAME##_##I17,\
+    NAME##_##I18,\
+    NAME##_##I19,\
+    NAME##_##I20,\
+    NAME##_##I21,\
+    NAME##_##I22,\
+    NAME##_##I23,\
+    NAME##_##I24,\
+    NAME##_##I25 \
+    ,NAME##_NULL \
+  }; \
+  template <class Manip>\
+  class NAME##_value_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_value_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_##field_list {\
+  public: \
+    const NAME *obj; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    NAME##_field_list (const NAME *o, const char *d, Manip m) \
+      : obj(o), delim(d), manip(m) {} \
+  };\
+  template <class Manip>\
+  class NAME##_equal_list { \
+  public: \
+    const NAME *obj;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public: \
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) \
+      : obj(o), delim(d), comp(c), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_value_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25);\
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25); \
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)\
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+  template <class Manip>\
+  class NAME##_cus_field_list { \
+  public:\
+    const NAME *obj; \
+    std::vector<bool> *include; \
+    bool del_vector; \
+    const char *delim;\
+    Manip manip;\
+  public: \
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25); \
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}\
+  };\
+ template <class Manip>\
+ class NAME##_cus_equal_list {\
+  public:\
+    const NAME *obj;\
+    std::vector<bool> *include;\
+    bool del_vector;\
+    const char *delim;\
+    const char *comp;\
+    Manip manip;\
+  public:\
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}\
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25); \
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) \
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}\
+  };\
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);\
+  struct NAME { \
+    T1 I1;\
+    T2 I2;\
+    T3 I3;\
+    T4 I4;\
+    T5 I5;\
+    T6 I6;\
+    T7 I7;\
+    T8 I8;\
+    T9 I9;\
+    T10 I10;\
+    T11 I11;\
+    T12 I12;\
+    T13 I13;\
+    T14 I14;\
+    T15 I15;\
+    T16 I16;\
+    T17 I17;\
+    T18 I18;\
+    T19 I19;\
+    T20 I20;\
+    T21 I21;\
+    T22 I22;\
+    T23 I23;\
+    T24 I24;\
+    T25 I25; \
+    NAME() : table_override_(0) {} \
+    NAME(const mysqlpp::Row& row);\
+    void set(const mysqlpp::Row &row);\
+    sql_compare_define_##CMP(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23, T24, I24, T25, I25)\
+    sql_construct_define_##CONTR(NAME, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23, T24, I24, T25, I25)\
+    static const char* names[];\
+    static void table(const char* t) { table_ = t; }\
+    const char* const table() const\
+            { return table_override_ ? table_override_ : NAME::table_; }\
+    void instance_table(const char* t) { table_override_ = t; }\
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {\
+      return value_list(",", mysqlpp::quote);}\
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {\
+      return value_list(d, mysqlpp::quote);}\
+    template <class Manip> \
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; \
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {\
+      return field_list(",", mysqlpp::do_nothing);}\
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {\
+      return field_list(d, mysqlpp::do_nothing);}\
+    template <class Manip>\
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; \
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", \
+                                              const char *c = " = ") const{\
+      return equal_list(d, c, mysqlpp::quote);}\
+    template <class Manip>\
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; \
+    /* cus_data */\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const {\
+      return value_list(",", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {\
+      return value_list(",", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {\
+      return value_list(",", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const {\
+      return value_list(d, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return value_list(d, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return value_list(d, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,\
+					  NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, \
+					  mysqlpp::sql_cmp_type sc) const;\
+    /* cus field */\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const {\
+      return field_list(",", mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {\
+      return field_list(",", mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const\
+    {\
+      return field_list(",", mysqlpp::do_nothing, sc);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+							   bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,\
+							   NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const {\
+      return field_list(d, mysqlpp::do_nothing, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return field_list(d, mysqlpp::do_nothing, i);\
+    }\
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return field_list(d, mysqlpp::do_nothing, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,\
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+    /* cus equal */\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {\
+      return equal_list(",", " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(",", " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						std::vector<bool> *i) const {\
+      return equal_list(d, " = ", mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, \
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, " = ", mysqlpp::quote, sc);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+                                                NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const {\
+      return equal_list(d, c, mysqlpp::quote, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						std::vector<bool> *i) const {\
+      return equal_list(d, c, mysqlpp::quote, i);\
+    }\
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,\
+						mysqlpp::sql_cmp_type sc) const {\
+      return equal_list(d, c, mysqlpp::quote, sc);\
+    }\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						bool i1, bool i2 = false, bool i3 = false, bool i4 = false, bool i5 = false, bool i6 = false, bool i7 = false, bool i8 = false, bool i9 = false, bool i10 = false, bool i11 = false, bool i12 = false, bool i13 = false, bool i14 = false, bool i15 = false, bool i16 = false, bool i17 = false, bool i18 = false, bool i19 = false, bool i20 = false, bool i21 = false, bool i22 = false, bool i23 = false, bool i24 = false, bool i25 = false) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						NAME##_enum i1, NAME##_enum i2 = NAME##_NULL, NAME##_enum i3 = NAME##_NULL, NAME##_enum i4 = NAME##_NULL, NAME##_enum i5 = NAME##_NULL, NAME##_enum i6 = NAME##_NULL, NAME##_enum i7 = NAME##_NULL, NAME##_enum i8 = NAME##_NULL, NAME##_enum i9 = NAME##_NULL, NAME##_enum i10 = NAME##_NULL, NAME##_enum i11 = NAME##_NULL, NAME##_enum i12 = NAME##_NULL, NAME##_enum i13 = NAME##_NULL, NAME##_enum i14 = NAME##_NULL, NAME##_enum i15 = NAME##_NULL, NAME##_enum i16 = NAME##_NULL, NAME##_enum i17 = NAME##_NULL, NAME##_enum i18 = NAME##_NULL, NAME##_enum i19 = NAME##_NULL, NAME##_enum i20 = NAME##_NULL, NAME##_enum i21 = NAME##_NULL, NAME##_enum i22 = NAME##_NULL, NAME##_enum i23 = NAME##_NULL, NAME##_enum i24 = NAME##_NULL, NAME##_enum i25 = NAME##_NULL) const; \
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						std::vector<bool> *i) const;\
+    template <class Manip>\
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, \
+						mysqlpp::sql_cmp_type sc) const;\
+  private:\
+    static const char* table_;\
+    const char* table_override_;\
+  }; \
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(\
+	  const char *NAME::names[] = { \
+		     N1 ,\
+    N2 ,\
+    N3 ,\
+    N4 ,\
+    N5 ,\
+    N6 ,\
+    N7 ,\
+    N8 ,\
+    N9 ,\
+    N10 ,\
+    N11 ,\
+    N12 ,\
+    N13 ,\
+    N14 ,\
+    N15 ,\
+    N16 ,\
+    N17 ,\
+    N18 ,\
+    N19 ,\
+    N20 ,\
+    N21 ,\
+    N22 ,\
+    N23 ,\
+    N24 ,\
+    N25 \
+	  }; \
+	  const char* NAME::table_ = #NAME;\
+  )\
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25) \
+  { \
+    delim = d;\
+    manip = m;\
+    del_vector = true;\
+    obj = o; \
+    include = new std::vector<bool>(25, false);\
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+    if (i24) (*include)[23]=true;\
+    if (i25) (*include)[24]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(25, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+    if (i24 == NAME##_NULL) return;\
+    (*include)[i24]=true;\
+    if (i25 == NAME##_NULL) return;\
+    (*include)[i25]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25) {\
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(25, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+    if (i24) (*include)[23]=true;\
+    if (i25) (*include)[24]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list\
+  (const NAME *o, const char *d, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25) { \
+    delim = d;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(25, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+    if (i24 == NAME##_NULL) return;\
+    (*include)[i24]=true;\
+    if (i25 == NAME##_NULL) return;\
+    (*include)[i25]=true;\
+  }\
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(25, false); \
+    if (i1) (*include)[0]=true;\
+    if (i2) (*include)[1]=true;\
+    if (i3) (*include)[2]=true;\
+    if (i4) (*include)[3]=true;\
+    if (i5) (*include)[4]=true;\
+    if (i6) (*include)[5]=true;\
+    if (i7) (*include)[6]=true;\
+    if (i8) (*include)[7]=true;\
+    if (i9) (*include)[8]=true;\
+    if (i10) (*include)[9]=true;\
+    if (i11) (*include)[10]=true;\
+    if (i12) (*include)[11]=true;\
+    if (i13) (*include)[12]=true;\
+    if (i14) (*include)[13]=true;\
+    if (i15) (*include)[14]=true;\
+    if (i16) (*include)[15]=true;\
+    if (i17) (*include)[16]=true;\
+    if (i18) (*include)[17]=true;\
+    if (i19) (*include)[18]=true;\
+    if (i20) (*include)[19]=true;\
+    if (i21) (*include)[20]=true;\
+    if (i22) (*include)[21]=true;\
+    if (i23) (*include)[22]=true;\
+    if (i24) (*include)[23]=true;\
+    if (i25) (*include)[24]=true;\
+  } \
+  template <class Manip>\
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list\
+  (const NAME *o, const char *d, const char *c, Manip m, NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25) { \
+    delim = d;\
+    comp = c;\
+    manip = m;\
+    del_vector = true; \
+    obj = o; \
+    include = new std::vector<bool>(25, false); \
+    if (i1 == NAME##_NULL) return;\
+    (*include)[i1]=true;\
+    if (i2 == NAME##_NULL) return;\
+    (*include)[i2]=true;\
+    if (i3 == NAME##_NULL) return;\
+    (*include)[i3]=true;\
+    if (i4 == NAME##_NULL) return;\
+    (*include)[i4]=true;\
+    if (i5 == NAME##_NULL) return;\
+    (*include)[i5]=true;\
+    if (i6 == NAME##_NULL) return;\
+    (*include)[i6]=true;\
+    if (i7 == NAME##_NULL) return;\
+    (*include)[i7]=true;\
+    if (i8 == NAME##_NULL) return;\
+    (*include)[i8]=true;\
+    if (i9 == NAME##_NULL) return;\
+    (*include)[i9]=true;\
+    if (i10 == NAME##_NULL) return;\
+    (*include)[i10]=true;\
+    if (i11 == NAME##_NULL) return;\
+    (*include)[i11]=true;\
+    if (i12 == NAME##_NULL) return;\
+    (*include)[i12]=true;\
+    if (i13 == NAME##_NULL) return;\
+    (*include)[i13]=true;\
+    if (i14 == NAME##_NULL) return;\
+    (*include)[i14]=true;\
+    if (i15 == NAME##_NULL) return;\
+    (*include)[i15]=true;\
+    if (i16 == NAME##_NULL) return;\
+    (*include)[i16]=true;\
+    if (i17 == NAME##_NULL) return;\
+    (*include)[i17]=true;\
+    if (i18 == NAME##_NULL) return;\
+    (*include)[i18]=true;\
+    if (i19 == NAME##_NULL) return;\
+    (*include)[i19]=true;\
+    if (i20 == NAME##_NULL) return;\
+    (*include)[i20]=true;\
+    if (i21 == NAME##_NULL) return;\
+    (*include)[i21]=true;\
+    if (i22 == NAME##_NULL) return;\
+    (*include)[i22]=true;\
+    if (i23 == NAME##_NULL) return;\
+    (*include)[i23]=true;\
+    if (i24 == NAME##_NULL) return;\
+    (*include)[i24]=true;\
+    if (i25 == NAME##_NULL) return;\
+    (*include)[i25]=true;\
+  }\
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.manip << obj.obj->I21 << obj.delim;\
+    s << obj.manip << obj.obj->I22 << obj.delim;\
+    s << obj.manip << obj.obj->I23 << obj.delim;\
+    s << obj.manip << obj.obj->I24 << obj.delim;\
+    s << obj.manip << obj.obj->I25; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { \
+    s << obj.manip << obj.obj->names[0] << obj.delim;\
+    s << obj.manip << obj.obj->names[1] << obj.delim;\
+    s << obj.manip << obj.obj->names[2] << obj.delim;\
+    s << obj.manip << obj.obj->names[3] << obj.delim;\
+    s << obj.manip << obj.obj->names[4] << obj.delim;\
+    s << obj.manip << obj.obj->names[5] << obj.delim;\
+    s << obj.manip << obj.obj->names[6] << obj.delim;\
+    s << obj.manip << obj.obj->names[7] << obj.delim;\
+    s << obj.manip << obj.obj->names[8] << obj.delim;\
+    s << obj.manip << obj.obj->names[9] << obj.delim;\
+    s << obj.manip << obj.obj->names[10] << obj.delim;\
+    s << obj.manip << obj.obj->names[11] << obj.delim;\
+    s << obj.manip << obj.obj->names[12] << obj.delim;\
+    s << obj.manip << obj.obj->names[13] << obj.delim;\
+    s << obj.manip << obj.obj->names[14] << obj.delim;\
+    s << obj.manip << obj.obj->names[15] << obj.delim;\
+    s << obj.manip << obj.obj->names[16] << obj.delim;\
+    s << obj.manip << obj.obj->names[17] << obj.delim;\
+    s << obj.manip << obj.obj->names[18] << obj.delim;\
+    s << obj.manip << obj.obj->names[19] << obj.delim;\
+    s << obj.manip << obj.obj->names[20] << obj.delim;\
+    s << obj.manip << obj.obj->names[21] << obj.delim;\
+    s << obj.manip << obj.obj->names[22] << obj.delim;\
+    s << obj.manip << obj.obj->names[23] << obj.delim;\
+    s << obj.manip << obj.obj->names[24]; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { \
+    s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1 << obj.delim;\
+    s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2 << obj.delim;\
+    s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3 << obj.delim;\
+    s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4 << obj.delim;\
+    s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5 << obj.delim;\
+    s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6 << obj.delim;\
+    s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7 << obj.delim;\
+    s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8 << obj.delim;\
+    s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9 << obj.delim;\
+    s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10 << obj.delim;\
+    s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11 << obj.delim;\
+    s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12 << obj.delim;\
+    s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13 << obj.delim;\
+    s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14 << obj.delim;\
+    s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15 << obj.delim;\
+    s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16 << obj.delim;\
+    s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17 << obj.delim;\
+    s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18 << obj.delim;\
+    s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19 << obj.delim;\
+    s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20 << obj.delim;\
+    s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21 << obj.delim;\
+    s << obj.obj->names[21] << obj.comp << obj.manip << obj.obj->I22 << obj.delim;\
+    s << obj.obj->names[22] << obj.comp << obj.manip << obj.obj->I23 << obj.delim;\
+    s << obj.obj->names[23] << obj.comp << obj.manip << obj.obj->I24 << obj.delim;\
+    s << obj.obj->names[24] << obj.comp << obj.manip << obj.obj->I25; \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I21;\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I22;\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I23;\
+      before = true; \
+     } \
+    if ((*obj.include)[23]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I24;\
+      before = true; \
+     } \
+    if ((*obj.include)[24]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->I25;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.manip << obj.obj->names[0];\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[1];\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[2];\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[3];\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[4];\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[5];\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[6];\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[7];\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[8];\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[9];\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[10];\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[11];\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[12];\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[13];\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[14];\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[15];\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[16];\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[17];\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[18];\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[19];\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[20];\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[21];\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[22];\
+      before = true; \
+     } \
+    if ((*obj.include)[23]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[23];\
+      before = true; \
+     } \
+    if ((*obj.include)[24]) { \
+      if (before) s << obj.delim;\
+      s << obj.manip << obj.obj->names[24];\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { \
+    bool before = false; \
+    if ((*obj.include)[0]) { \
+      s << obj.obj->names[0] << obj.comp << obj.manip << obj.obj->I1;\
+      before = true; \
+     } \
+    if ((*obj.include)[1]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[1] << obj.comp << obj.manip << obj.obj->I2;\
+      before = true; \
+     } \
+    if ((*obj.include)[2]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[2] << obj.comp << obj.manip << obj.obj->I3;\
+      before = true; \
+     } \
+    if ((*obj.include)[3]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[3] << obj.comp << obj.manip << obj.obj->I4;\
+      before = true; \
+     } \
+    if ((*obj.include)[4]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[4] << obj.comp << obj.manip << obj.obj->I5;\
+      before = true; \
+     } \
+    if ((*obj.include)[5]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[5] << obj.comp << obj.manip << obj.obj->I6;\
+      before = true; \
+     } \
+    if ((*obj.include)[6]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[6] << obj.comp << obj.manip << obj.obj->I7;\
+      before = true; \
+     } \
+    if ((*obj.include)[7]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[7] << obj.comp << obj.manip << obj.obj->I8;\
+      before = true; \
+     } \
+    if ((*obj.include)[8]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[8] << obj.comp << obj.manip << obj.obj->I9;\
+      before = true; \
+     } \
+    if ((*obj.include)[9]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[9] << obj.comp << obj.manip << obj.obj->I10;\
+      before = true; \
+     } \
+    if ((*obj.include)[10]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[10] << obj.comp << obj.manip << obj.obj->I11;\
+      before = true; \
+     } \
+    if ((*obj.include)[11]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[11] << obj.comp << obj.manip << obj.obj->I12;\
+      before = true; \
+     } \
+    if ((*obj.include)[12]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[12] << obj.comp << obj.manip << obj.obj->I13;\
+      before = true; \
+     } \
+    if ((*obj.include)[13]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[13] << obj.comp << obj.manip << obj.obj->I14;\
+      before = true; \
+     } \
+    if ((*obj.include)[14]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[14] << obj.comp << obj.manip << obj.obj->I15;\
+      before = true; \
+     } \
+    if ((*obj.include)[15]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[15] << obj.comp << obj.manip << obj.obj->I16;\
+      before = true; \
+     } \
+    if ((*obj.include)[16]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[16] << obj.comp << obj.manip << obj.obj->I17;\
+      before = true; \
+     } \
+    if ((*obj.include)[17]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[17] << obj.comp << obj.manip << obj.obj->I18;\
+      before = true; \
+     } \
+    if ((*obj.include)[18]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[18] << obj.comp << obj.manip << obj.obj->I19;\
+      before = true; \
+     } \
+    if ((*obj.include)[19]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[19] << obj.comp << obj.manip << obj.obj->I20;\
+      before = true; \
+     } \
+    if ((*obj.include)[20]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[20] << obj.comp << obj.manip << obj.obj->I21;\
+      before = true; \
+     } \
+    if ((*obj.include)[21]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[21] << obj.comp << obj.manip << obj.obj->I22;\
+      before = true; \
+     } \
+    if ((*obj.include)[22]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[22] << obj.comp << obj.manip << obj.obj->I23;\
+      before = true; \
+     } \
+    if ((*obj.include)[23]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[23] << obj.comp << obj.manip << obj.obj->I24;\
+      before = true; \
+     } \
+    if ((*obj.include)[24]) { \
+      if (before) s << obj.delim;\
+      s << obj.obj->names[24] << obj.comp << obj.manip << obj.obj->I25;\
+     } \
+    return s; \
+  } \
+  template <class Manip>\
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { \
+    return NAME##_value_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { \
+    return NAME##_field_list<Manip> (this, d, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { \
+    return NAME##_equal_list<Manip> (this, d, c, m); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25) const { \
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+							 bool i1, bool i2, bool i3, bool i4, bool i5, bool i6, bool i7, bool i8, bool i9, bool i10, bool i11, bool i12, bool i13, bool i14, bool i15, bool i16, bool i17, bool i18, bool i19, bool i20, bool i21, bool i22, bool i23, bool i24, bool i25) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+							   NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25) const { \
+    return NAME##_cus_value_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, \
+							 NAME##_enum i1, NAME##_enum i2, NAME##_enum i3, NAME##_enum i4, NAME##_enum i5, NAME##_enum i6, NAME##_enum i7, NAME##_enum i8, NAME##_enum i9, NAME##_enum i10, NAME##_enum i11, NAME##_enum i12, NAME##_enum i13, NAME##_enum i14, NAME##_enum i15, NAME##_enum i16, NAME##_enum i17, NAME##_enum i18, NAME##_enum i19, NAME##_enum i20, NAME##_enum i21, NAME##_enum i22, NAME##_enum i23, NAME##_enum i24, NAME##_enum i25) const { \
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23, i24, i25); \
+  } \
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_value_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_field_list<Manip> (this, d, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,\
+                                                       std::vector<bool> *i) const {\
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_value_list<Manip> \
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, value, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_field_list<Manip> \
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_def_##CMP(NAME, field, NUM);\
+  }\
+  template <class Manip>\
+  inline NAME##_cus_equal_list<Manip> \
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {\
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);\
+  }\
+  template <mysqlpp::sql_dummy_type dummy> \
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { \
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);\
+    s->I1 = row[N1].conv(T1());\
+    s->I2 = row[N2].conv(T2());\
+    s->I3 = row[N3].conv(T3());\
+    s->I4 = row[N4].conv(T4());\
+    s->I5 = row[N5].conv(T5());\
+    s->I6 = row[N6].conv(T6());\
+    s->I7 = row[N7].conv(T7());\
+    s->I8 = row[N8].conv(T8());\
+    s->I9 = row[N9].conv(T9());\
+    s->I10 = row[N10].conv(T10());\
+    s->I11 = row[N11].conv(T11());\
+    s->I12 = row[N12].conv(T12());\
+    s->I13 = row[N13].conv(T13());\
+    s->I14 = row[N14].conv(T14());\
+    s->I15 = row[N15].conv(T15());\
+    s->I16 = row[N16].conv(T16());\
+    s->I17 = row[N17].conv(T17());\
+    s->I18 = row[N18].conv(T18());\
+    s->I19 = row[N19].conv(T19());\
+    s->I20 = row[N20].conv(T20());\
+    s->I21 = row[N21].conv(T21());\
+    s->I22 = row[N22].conv(T22());\
+    s->I23 = row[N23].conv(T23());\
+    s->I24 = row[N24].conv(T24());\
+    s->I25 = row[N25].conv(T25());\
+  } \
+  inline NAME::NAME(const mysqlpp::Row& row) :\
+  table_override_(0)\
+  {\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  inline void NAME::set(const mysqlpp::Row& row)\
+  {\
+	table_override_ = 0;\
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);\
+  }\
+  sql_COMPARE__##CMP(NAME, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25 )
+
+#define sql_create_25(NAME, CMP, CONTR, T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6, T7, I7, T8, I8, T9, I9, T10, I10, T11, I11, T12, I12, T13, I13, T14, I14, T15, I15, T16, I16, T17, I17, T18, I18, T19, I19, T20, I20, T21, I21, T22, I22, T23, I23, T24, I24, T25, I25) \
+  sql_create_complete_25(NAME, CMP, CONTR, T1, I1, #I1, T2, I2, #I2, T3, I3, #I3, T4, I4, #I4, T5, I5, #I5, T6, I6, #I6, T7, I7, #I7, T8, I8, #I8, T9, I9, #I9, T10, I10, #I10, T11, I11, #I11, T12, I12, #I12, T13, I13, #I13, T14, I14, #I14, T15, I15, #I15, T16, I16, #I16, T17, I17, #I17, T18, I18, #I18, T19, I19, #I19, T20, I20, #I20, T21, I21, #I21, T22, I22, #I22, T23, I23, #I23, T24, I24, #I24, T25, I25, #I25) \
+
+// ---------------------------------------------------
+//                  End Create 25
+// ---------------------------------------------------
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_SSQLS_H)
+

ADDED   lib/ssqls.pl
Index: lib/ssqls.pl
==================================================================
--- /dev/null
+++ lib/ssqls.pl
@@ -0,0 +1,930 @@
+#!/usr/bin/perl -w
+
+########################################################################
+# ssqls.pl - Generates ssqls.h, as it defines many near-duplicate
+#   functions and classes, varying only in trivial ways.
+#
+# Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+# (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+# also hold copyrights on code in this file.  See the CREDITS file in
+# the top directory of the distribution for details.
+#
+# This file is part of MySQL++.
+#
+# MySQL++ is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with MySQL++; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+# USA
+########################################################################
+
+
+# This is the limit on the number of SSQLS data members.  Higher values
+# will make ssqls.h exponentially larger.  This will increase compile
+# times and may even expose limits in your compiler.  Increase it only
+# if and as far as you must.
+my $max_data_members = 25;
+
+# To make comparisons between floating point values, we subtract them,
+# take the absolute value, and test to see if that delta is under this
+# value.  If it is, we call the two values "equal".  Change this as fits
+# your need for precision.  Note that we express it as a string because
+# we want the value copied literally into ssqls.h, not "preprocessed" 
+# by Perl as a floating-point value.
+my $fp_min_delta = "0.00001";
+
+
+# No user-serviceable parts below.
+
+use strict;
+
+open (OUT, ">ssqls.h");
+
+print OUT << "---";
+
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// This file is generated by the Perl script ssqls.pl.  Do not modify
+// it directly.  Change the script instead.
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+#if !defined(MYSQLPP_SSQLS_H)
+#define MYSQLPP_SSQLS_H
+
+#include "noexceptions.h"
+#include "sql_types.h"
+
+#if !defined(MYSQLPP_SSQLS_COMPATIBLE)
+#	error Your compiler is not compatible with the SSQLS feature!
+#endif
+
+#include <string>
+
+#include <math.h>
+
+// Smallest difference between two floating point numbers recognized
+// in making comparisons.  If the absolute delta is under this
+// threshold, the two values are considered equal.  You can either
+// override this permanently by changing ssqls.pl, or you can do it
+// on a case-by-case basis at compile time by defining this to another
+// value before #including this header.
+#if !defined(MYSQLPP_FP_MIN_DELTA)
+#	define MYSQLPP_FP_MIN_DELTA $fp_min_delta
+#endif
+
+namespace mysqlpp {
+
+enum sql_dummy_type { sql_dummy };
+
+#ifdef MYSQLPP_SSQLS_NO_STATICS
+#	define MYSQLPP_SSQLS_CONDITIONAL_STATICS(...)
+#else
+#	define MYSQLPP_SSQLS_CONDITIONAL_STATICS(...) __VA_ARGS__
+#endif
+
+---
+
+my @types = ("Date", "DateTime", "Time", "String", "std::string");
+foreach my $type (@types) {
+    print OUT << "---";
+
+inline int sql_cmp(const $type& a, const $type& b)
+{
+	return a.compare(b);
+}
+---
+}
+
+@types = (
+		"signed char", "unsigned char",
+		"sql_tinyint", "sql_tinyint_unsigned",
+		"signed int", "unsigned",
+		"signed short", "unsigned short",
+		"signed long", "unsigned long");
+foreach my $type (@types) {
+    print OUT << "---";
+
+inline int sql_cmp($type a, $type b)
+{
+	return a - b;
+}
+---
+}
+
+@types = ("longlong", "ulonglong");
+foreach my $type (@types) {
+    print OUT << "---";
+
+inline int sql_cmp($type a, $type b) 
+{
+	if (a == b) return 0;
+	if (a <  b) return -1;
+	return 1;
+}
+---
+}	
+
+@types = ("double", "float");
+foreach my $type (@types) {
+    print OUT << "---";
+
+inline int sql_cmp($type a, $type b) 
+{
+	if (fabs(a - b) < MYSQLPP_FP_MIN_DELTA) return 0;
+	if (a <  b) return -1;
+	return 1;
+}
+---
+}	
+
+print OUT << "---";
+
+template <typename T>
+inline int sql_cmp(const mysqlpp::Null<T>& a, const mysqlpp::Null<T>& b) 
+{
+	if (a == b) return 0;
+	if (a <  b) return -1;
+	return 1;
+}
+
+
+// ---------------------------------------------------
+//                Begin Mandatory Compare 
+// ---------------------------------------------------
+
+#define sql_compare_define(NAME) \\
+    bool operator == (const NAME &other) const \\
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) == 0;} \\
+    bool operator != (const NAME &other) const \\
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) != 0;} \\
+    bool operator > (const NAME &other) const \\
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) >  0;} \\
+    bool operator < (const NAME &other) const \\
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) <  0;} \\
+    bool operator >= (const NAME &other) const \\
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) >= 0;} \\
+    bool operator <= (const NAME &other) const \\
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) <= 0;} \\
+    int cmp (const NAME &other) const \\
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other);} \\
+    int compare (const NAME &other) const \\
+      {return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other);}
+---
+
+my ($parm0, $parm1);
+
+foreach my $j (1..$max_data_members) {
+    $parm0 .= "T$j, C$j";
+    $parm0 .= ", " unless $j == $max_data_members;
+    $parm1 .= "C$j";
+    $parm1 .= ", " unless $j == $max_data_members;
+}
+
+print OUT << "---";
+
+#define sql_compare_define_0(NAME, $parm0)
+
+#define sql_construct_define_0(NAME, $parm0)
+
+#define sql_COMPARE__0(NAME, $parm1)
+
+#define sql_compare_type_def_0(NAME, WHAT, NUM) \\
+  sql_compare_type_def_##NUM(NAME, WHAT, NUM)
+
+#define sql_compare_type_defe_0(NAME, WHAT, NUM) \\
+  sql_compare_type_defe_##NUM(NAME, WHAT, NUM)
+
+// ---------------------------------------------------
+//                 End Mandatory Compare 
+// ---------------------------------------------------
+---
+
+
+foreach my $i (1..$max_data_members) {
+	my ($compr, $define, $compp, $set, $parm2);
+
+	$compr = ""; $parm2 = ""; $define = "";
+	$compr = "    int cmp; \\\n" unless $i == 1;
+	$compp = "";
+	$set = "";
+
+	foreach my $j (1..$i) {
+		if ($j != $i) {
+			$compr .= "    cmp = mysqlpp::sql_cmp(x.C$j , y.C$j ); \\\n";
+			$compr .= "    if (cmp) return cmp; \\\n";
+		}
+
+		$compr .= "    return mysqlpp::sql_cmp(x.C$j , y.C$j );" if $j == $i;
+		$parm2 .= "const T$j &p$j";
+		$parm2 .= ", " unless $j == $i;
+		$define.= "C$j (p$j)";
+		$define.= ", " unless $j == $i;
+		$set   .= "    C$j = p$j;\\\n";
+		$compp .= "true";
+		$compp .= ", " unless $j == $i;
+	}
+	print OUT << "---";
+
+// ---------------------------------------------------
+//                   Begin Compare $i
+// ---------------------------------------------------
+
+#define sql_compare_define_$i(NAME, $parm0) \\
+  NAME($parm2) : $define, table_override_(0) {} \\
+  void set($parm2) { \\
+	table_override_ = 0; \\
+$set \\
+  } \\
+  sql_compare_define(NAME)
+
+#define sql_construct_define_$i(NAME, $parm0) \\
+  void set($parm2) { \\
+	table_override_ = 0; \\
+$set \\
+  } \\
+  NAME($parm2) : $define, table_override_(0) {}
+
+#define sql_compare_type_def_$i(NAME, WHAT, NUM) \\
+  return WHAT##_list(d, m, $compp)
+
+#define sql_compare_type_defe_$i(NAME, WHAT, NUM) \\
+  return WHAT##_list(d, c, m, $compp)
+
+#define sql_COMPARE__$i(NAME, $parm1) \\
+  template <mysqlpp::sql_dummy_type dummy> \\
+  int sql_compare_##NAME(const NAME &x, const NAME &y) { \\
+$compr \\
+  } \\
+  template <mysqlpp::sql_dummy_type dummy> \\
+  int compare (const NAME &x, const NAME &y) { \\
+$compr \\
+  }
+
+// ---------------------------------------------------
+//                   End Compare $i
+// ---------------------------------------------------
+
+---
+}
+
+
+foreach my $i (1..$max_data_members) {
+    my $create_bool = "";
+	my $create_list = "";
+	my $cus_equal_list = "";
+	my $cus_field_list = "";
+    my $cusparms1 = "";
+    my $cusparms11 = "";
+	my $cusparms2 = "";
+	my $cusparms22 = "";
+	my $cusparmsv = "";    
+    my $defs = "";
+	my $enums = "";
+	my $equal_list = "";
+	my $field_list = "";
+    my $names = "";
+	my $parmc = "";
+	my $parmC = "";
+    my $parm_complete = ""; 
+    my $parm_simple = "";
+	my $parm_simple2c = "";
+	my $parm_simple2c_b = "";
+    my $parm_simple_b = "";
+	my $popul = "";
+    my $value_list = "";
+    my $value_list_cus = "";
+
+    foreach my $j (1 .. $i) {
+		$parm_complete .= "T$j, I$j, N$j";
+		$parm_complete .= ", " unless $j == $i;
+		$parm_simple   .= "T$j, I$j";
+		$parm_simple   .= ", " unless $j == $i;
+		$parm_simple2c .= "T$j, I$j, #I$j";
+		$parm_simple2c .= ", " unless $j == $i;
+		$parm_simple_b   .= "T$j, I$j";
+		$parm_simple_b   .= ", " unless $j == $i;
+		$parm_simple2c_b .= "T$j, I$j";
+		$parm_simple2c_b .= ", " unless $j == $i;
+
+		$defs  .= "    T$j I$j;";
+		$defs  .= "\n" unless $j == $i;
+
+		$popul .= "    s->I$j = row[N$j].conv(T$j());";
+		$popul .= "\n" unless $j == $i;
+
+		$names .= "    N$j ";
+		$names .= ",\n" unless $j == $i;
+		$enums .= "    NAME##_##I$j";
+		$enums .= ",\n" unless $j == $i;
+
+		$field_list .= "    s << obj.manip << obj.obj->names[".($j-1)."]";
+		$field_list .= " << obj.delim;\n" unless $j == $i;
+
+		$value_list .= "    s << obj.manip << obj.obj->I$j";
+		$value_list .= " << obj.delim;\n" unless $j == $i;
+
+		$create_bool .= "    if (i$j) (*include)[".($j-1)."]=true;\n";
+
+		$create_list .= "    if (i$j == NAME##_NULL) return;\n" unless $i == 1;
+		$create_list .= "    (*include)[i$j]=true;\n";
+
+		$value_list_cus .= "    if ((*obj.include)[".($j-1)."]) { \n";
+		$value_list_cus .= "      if (before) s << obj.delim;\n" unless $j == 1;
+		$value_list_cus .= "      s << obj.manip << obj.obj->I$j;\n";
+		$value_list_cus .= "      before = true; \n" unless $j == $i;
+		$value_list_cus .= "     } \n";
+
+		$cus_field_list .= "    if ((*obj.include)[".($j-1)."]) { \n";
+		$cus_field_list .= "      if (before) s << obj.delim;\n" unless $j == 1;
+		$cus_field_list .= "      s << obj.manip << obj.obj->names[".($j-1)."];\n";
+		$cus_field_list .= "      before = true; \n" unless $j == $i;
+		$cus_field_list .= "     } \n";
+
+		$cus_equal_list .= "    if ((*obj.include)[".($j-1)."]) { \n";
+		$cus_equal_list .= "      if (before) s << obj.delim;\n" unless $j == 1;
+		$cus_equal_list .= "      s << obj.obj->names[".($j-1)."] << obj.comp";
+		$cus_equal_list .=        " << obj.manip << obj.obj->I$j;\n";
+		$cus_equal_list .= "      before = true; \n" unless $j == $i;
+		$cus_equal_list .= "     } \n";
+
+		$equal_list .= "    s << obj.obj->names[".($j-1)."] << obj.comp";
+		$equal_list .= " << obj.manip << obj.obj->I$j";
+		$equal_list .= " << obj.delim;\n" unless $j == $i;
+
+		$cusparms1  .= "bool i$j"         if     $j == 1;
+		$cusparms1  .= "bool i$j = false" unless $j == 1;
+		$cusparms1  .= ", " unless $j == $i;
+		$cusparms11  .= "bool i$j" ;
+		$cusparms11  .= ", " unless $j == $i;
+		$cusparms2  .= "NAME##_enum i$j" if $j == 1;
+		$cusparms2  .= "NAME##_enum i$j = NAME##_NULL" unless $j == 1;
+		$cusparms2  .= ", " unless $j == $i;
+		$cusparms22  .= "NAME##_enum i$j";
+		$cusparms22  .= ", " unless $j == $i;
+		$cusparmsv  .= "i$j";
+		$cusparmsv  .= ", " unless $j == $i;
+
+		$parmC .= "T$j, I$j";
+		$parmC .= ", " unless $j == $max_data_members;
+		$parmc .= "I$j";
+		$parmc .= ", " unless $j == $max_data_members;
+    }
+
+    foreach my $j ($i + 1 .. $max_data_members) {
+		$parmC .= "0, 0";
+		$parmC .= ", " unless $j == $max_data_members;
+		$parmc .= "0";
+		$parmc .= ", " unless $j == $max_data_members;
+    }
+
+    print OUT << "---";
+// ---------------------------------------------------
+//                  Begin Create $i
+// ---------------------------------------------------
+---
+    my $out = <<"---";
+#define sql_create_complete_$i(NAME, CMP, CONTR, $parm_complete) 
+  struct NAME; 
+
+  enum NAME##_enum { 
+$enums 
+    ,NAME##_NULL 
+  }; 
+
+  template <class Manip>
+  class NAME##_value_list { 
+  public: 
+    const NAME *obj;
+    const char *delim;
+    Manip manip;
+  public: 
+    NAME##_value_list (const NAME *o, const char *d, Manip m) 
+      : obj(o), delim(d), manip(m) {} 
+  };
+
+  template <class Manip>
+  class NAME##_##field_list {
+  public: 
+    const NAME *obj; 
+    const char *delim;
+    Manip manip;
+  public: 
+    NAME##_field_list (const NAME *o, const char *d, Manip m) 
+      : obj(o), delim(d), manip(m) {} 
+  };
+
+  template <class Manip>
+  class NAME##_equal_list { 
+  public: 
+    const NAME *obj;
+    const char *delim;
+    const char *comp;
+    Manip manip;
+  public: 
+    NAME##_equal_list (const NAME *o, const char *d, const char *c, Manip m) 
+      : obj(o), delim(d), comp(c), manip(m) {}
+  };
+
+  template <class Manip>
+  class NAME##_cus_value_list {
+  public:
+    const NAME *obj;
+    std::vector<bool> *include;
+    bool del_vector;
+    const char *delim;
+    Manip manip;
+  public: 
+    ~NAME##_cus_value_list () {if (del_vector) delete include;} 
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, $cusparms11);
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m, $cusparms22); 
+    NAME##_cus_value_list (const NAME *o, const char *d, Manip m ,std::vector<bool>* i)
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}
+  };
+
+  template <class Manip>
+  class NAME##_cus_field_list { 
+  public:
+    const NAME *obj; 
+    std::vector<bool> *include; 
+    bool del_vector; 
+    const char *delim;
+    Manip manip;
+  public: 
+    ~NAME##_cus_field_list () {if (del_vector) delete include;} 
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, $cusparms11); 
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, $cusparms22); 
+    NAME##_cus_field_list (const NAME *o, const char *d, Manip m, std::vector<bool> *i) 
+      : obj(o), include(i), del_vector(false), delim(d), manip(m) {}
+  };
+
+ template <class Manip>
+ class NAME##_cus_equal_list {
+  public:
+    const NAME *obj;
+    std::vector<bool> *include;
+    bool del_vector;
+    const char *delim;
+    const char *comp;
+    Manip manip;
+  public:
+    ~NAME##_##cus_equal_list () {if (del_vector) delete include;}
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, $cusparms11); 
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, $cusparms22); 
+    NAME##_##cus_equal_list (const NAME *o, const char *d, const char *c, Manip m, std::vector<bool> *i) 
+      : obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) {}
+  };
+
+  template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);
+
+  struct NAME { 
+$defs 
+    NAME() : table_override_(0) {} 
+    NAME(const mysqlpp::Row& row);
+    void set(const mysqlpp::Row &row);
+    sql_compare_define_##CMP(NAME, $parmC)
+    sql_construct_define_##CONTR(NAME, $parmC)
+    static const char* names[];
+    static void table(const char* t) { table_ = t; }
+    const char* const table() const
+            { return table_override_ ? table_override_ : NAME::table_; }
+    void instance_table(const char* t) { table_override_ = t; }
+
+    NAME##_value_list<mysqlpp::quote_type0> value_list() const {
+      return value_list(",", mysqlpp::quote);}
+    NAME##_value_list<mysqlpp::quote_type0> value_list(const char *d) const {
+      return value_list(d, mysqlpp::quote);}
+    template <class Manip> 
+    NAME##_value_list<Manip> value_list(const char *d, Manip m) const; 
+
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {
+      return field_list(",", mysqlpp::do_nothing);}
+    NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char *d) const {
+      return field_list(d, mysqlpp::do_nothing);}
+    template <class Manip>
+    NAME##_field_list<Manip> field_list(const char *d, Manip m) const; 
+
+    NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char *d = ",", 
+                                              const char *c = " = ") const{
+      return equal_list(d, c, mysqlpp::quote);}
+    template <class Manip>
+    NAME##_equal_list<Manip> equal_list(const char *d, const char *c, Manip m) const; 
+    
+    /* cus_data */
+
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list($cusparms1) const {
+      return value_list(",", mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list($cusparms2) const {
+      return value_list(",", mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const {
+      return value_list(",", mysqlpp::quote, i);
+    }
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const {
+      return value_list(",", mysqlpp::quote, sc);
+    }
+
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, $cusparms1) const {
+      return value_list(d, mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, $cusparms2) const {
+      return value_list(d, mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, 
+						std::vector<bool> *i) const {
+      return value_list(d, mysqlpp::quote, i);
+    }
+    NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char *d, 
+						mysqlpp::sql_cmp_type sc) const {
+      return value_list(d, mysqlpp::quote, sc);
+    }
+
+    template <class Manip>
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,
+					  $cusparms1) const; 
+    template <class Manip>
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m,
+					  $cusparms2) const; 
+    template <class Manip>
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, 
+					  std::vector<bool> *i) const;
+    template <class Manip>
+    NAME##_cus_value_list<Manip> value_list(const char *d, Manip m, 
+					  mysqlpp::sql_cmp_type sc) const;
+    /* cus field */
+
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list($cusparms1) const {
+      return field_list(",", mysqlpp::do_nothing, $cusparmsv);
+    }
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list($cusparms2) const {
+      return field_list(",", mysqlpp::do_nothing, $cusparmsv);
+    }
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const {
+      return field_list(",", mysqlpp::do_nothing, i);
+    }
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const
+    {
+      return field_list(",", mysqlpp::do_nothing, sc);
+    }
+
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, 
+							   $cusparms1) const {
+      return field_list(d, mysqlpp::do_nothing, $cusparmsv);
+    }
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d,
+							   $cusparms2) const {
+      return field_list(d, mysqlpp::do_nothing, $cusparmsv);
+    }
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, 
+						std::vector<bool> *i) const {
+      return field_list(d, mysqlpp::do_nothing, i);
+    }
+    NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char *d, 
+						mysqlpp::sql_cmp_type sc) const {
+      return field_list(d, mysqlpp::do_nothing, sc);
+    }
+
+    template <class Manip>
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,
+						$cusparms1) const; 
+    template <class Manip>
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,
+						$cusparms2) const; 
+    template <class Manip>
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m,
+						std::vector<bool> *i) const;
+    template <class Manip>
+    NAME##_cus_field_list<Manip> field_list(const char *d, Manip m, 
+						mysqlpp::sql_cmp_type sc) const;
+
+    /* cus equal */
+
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list($cusparms1) const {
+      return equal_list(",", " = ", mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list($cusparms2) const {
+      return equal_list(",", " = ", mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool> *i) const {
+      return equal_list(",", " = ", mysqlpp::quote, i);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const {
+      return equal_list(",", " = ", mysqlpp::quote, sc);
+    }
+
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, $cusparms1) const {
+      return equal_list(d, " = ", mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, $cusparms2) const {
+      return equal_list(d, " = ", mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, 
+						std::vector<bool> *i) const {
+      return equal_list(d, " = ", mysqlpp::quote, i);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, 
+						mysqlpp::sql_cmp_type sc) const {
+      return equal_list(d, " = ", mysqlpp::quote, sc);
+    }
+
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,
+                                                $cusparms1) const {
+      return equal_list(d, c, mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,
+                                                $cusparms2) const {
+      return equal_list(d, c, mysqlpp::quote, $cusparmsv);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,
+						std::vector<bool> *i) const {
+      return equal_list(d, c, mysqlpp::quote, i);
+    }
+    NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char *d, const char *c,
+						mysqlpp::sql_cmp_type sc) const {
+      return equal_list(d, c, mysqlpp::quote, sc);
+    }
+
+    template <class Manip>
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, 
+						$cusparms1) const; 
+    template <class Manip>
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, 
+						$cusparms2) const; 
+    template <class Manip>
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, 
+						std::vector<bool> *i) const;
+    template <class Manip>
+    NAME##_cus_equal_list<Manip> equal_list(const char *d, const char *c, Manip m, 
+						mysqlpp::sql_cmp_type sc) const;
+
+  private:
+    static const char* table_;
+    const char* table_override_;
+  }; 
+  MYSQLPP_SSQLS_CONDITIONAL_STATICS(
+	  const char *NAME::names[] = { 
+		 $names
+	  }; 
+	  const char* NAME::table_ = #NAME;
+  )
+
+  template <class Manip>
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list
+  (const NAME *o, const char *d, Manip m, $cusparms11) 
+  { 
+    delim = d;
+    manip = m;
+    del_vector = true;
+    obj = o; 
+    include = new std::vector<bool>($i, false);
+$create_bool 
+  } 
+
+  template <class Manip>
+  NAME##_cus_value_list<Manip>::NAME##_cus_value_list
+  (const NAME *o, const char *d, Manip m, $cusparms22) { 
+    delim = d;
+    manip = m;
+    del_vector = true; 
+    obj = o; 
+    include = new std::vector<bool>($i, false); 
+$create_list 
+  }
+
+  template <class Manip>
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list
+  (const NAME *o, const char *d, Manip m, $cusparms11) {
+    delim = d;
+    manip = m;
+    del_vector = true; 
+    obj = o; 
+    include = new std::vector<bool>($i, false); 
+$create_bool 
+  } 
+
+  template <class Manip>
+  NAME##_cus_field_list<Manip>::NAME##_cus_field_list
+  (const NAME *o, const char *d, Manip m, $cusparms22) { 
+    delim = d;
+    manip = m;
+    del_vector = true; 
+    obj = o; 
+    include = new std::vector<bool>($i, false); 
+$create_list 
+  }
+
+  template <class Manip>
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list
+  (const NAME *o, const char *d, const char *c, Manip m, $cusparms11) { 
+    delim = d;
+    comp = c;
+    manip = m;
+    del_vector = true; 
+    obj = o; 
+    include = new std::vector<bool>($i, false); 
+$create_bool 
+  } 
+
+  template <class Manip>
+  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list
+  (const NAME *o, const char *d, const char *c, Manip m, $cusparms22) { 
+    delim = d;
+    comp = c;
+    manip = m;
+    del_vector = true; 
+    obj = o; 
+    include = new std::vector<bool>($i, false); 
+$create_list 
+  }
+
+  template <class Manip>
+  std::ostream& operator << (std::ostream& s, const NAME##_value_list<Manip>& obj) { 
+$value_list; 
+    return s; 
+  } 
+
+  template <class Manip>
+  std::ostream& operator << (std::ostream& s, const NAME##_field_list<Manip>& obj) { 
+$field_list; 
+    return s; 
+  } 
+
+  template <class Manip>
+  std::ostream& operator << (std::ostream& s, const NAME##_equal_list<Manip>& obj) { 
+$equal_list; 
+    return s; 
+  } 
+
+  template <class Manip>
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_value_list<Manip>& obj) { 
+    bool before = false; 
+$value_list_cus 
+    return s; 
+  } 
+
+  template <class Manip>
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_field_list<Manip>& obj) { 
+    bool before = false; 
+$cus_field_list 
+    return s; 
+  } 
+
+  template <class Manip>
+  std::ostream& operator << (std::ostream& s, const NAME##_cus_equal_list<Manip>& obj) { 
+    bool before = false; 
+$cus_equal_list 
+    return s; 
+  } 
+
+  template <class Manip>
+  inline NAME##_value_list<Manip> NAME::value_list(const char *d, Manip m) const { 
+    return NAME##_value_list<Manip> (this, d, m); 
+  } 
+
+  template <class Manip>
+  inline NAME##_field_list<Manip> NAME::field_list(const char *d, Manip m) const { 
+    return NAME##_field_list<Manip> (this, d, m); 
+  } 
+
+  template <class Manip>
+  inline NAME##_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m) const { 
+    return NAME##_equal_list<Manip> (this, d, c, m); 
+  } 
+ 
+  template <class Manip>
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,
+							   $cusparms11) const {
+    return NAME##_cus_value_list<Manip> (this, d, m, $cusparmsv); 
+  } 
+
+  template <class Manip>
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,
+							 $cusparms11) const { 
+    return NAME##_cus_field_list<Manip> (this, d, m, $cusparmsv); 
+  } 
+
+  template <class Manip>
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,
+							 $cusparms11) const { 
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, $cusparmsv); 
+  } 
+
+  template <class Manip>
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,
+							   $cusparms22) const { 
+    return NAME##_cus_value_list<Manip> (this, d, m, $cusparmsv); 
+  } 
+
+  template <class Manip>
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,
+							 $cusparms22) const {
+    return NAME##_cus_field_list<Manip> (this, d, m, $cusparmsv); 
+  } 
+
+  template <class Manip>
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m, 
+							 $cusparms22) const { 
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, $cusparmsv); 
+  } 
+
+  template <class Manip>
+  inline NAME##_cus_value_list<Manip> NAME::value_list(const char *d, Manip m,
+                                                       std::vector<bool> *i) const {
+    return NAME##_cus_value_list<Manip> (this, d, m, i);
+  }
+
+  template <class Manip>
+  inline NAME##_cus_field_list<Manip> NAME::field_list(const char *d, Manip m,
+                                                       std::vector<bool> *i) const {
+    return NAME##_cus_field_list<Manip> (this, d, m, i);
+  }
+
+  template <class Manip>
+  inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char *d, const char *c, Manip m,
+                                                       std::vector<bool> *i) const {
+    return NAME##_cus_equal_list<Manip> (this, d, c, m, i);
+  }
+
+  template <class Manip>
+  inline NAME##_cus_value_list<Manip> 
+  NAME::value_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {
+    sql_compare_type_def_##CMP(NAME, value, NUM);
+  }
+
+  template <class Manip>
+  inline NAME##_cus_field_list<Manip> 
+  NAME::field_list(const char *d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {
+    sql_compare_type_def_##CMP(NAME, field, NUM);
+  }
+
+  template <class Manip>
+  inline NAME##_cus_equal_list<Manip> 
+  NAME::equal_list(const char *d, const char *c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const {
+    sql_compare_type_defe_##CMP(NAME, equal, NUM);
+  }
+
+  template <mysqlpp::sql_dummy_type dummy> 
+  void populate_##NAME(NAME *s, const mysqlpp::Row &row) { 
+	mysqlpp::NoExceptions ignore_schema_mismatches(row);
+$popul
+  } 
+
+  inline NAME::NAME(const mysqlpp::Row& row) :
+  table_override_(0)
+  {
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);
+  }
+  inline void NAME::set(const mysqlpp::Row& row)
+  {
+	table_override_ = 0;
+    populate_##NAME<mysqlpp::sql_dummy>(this, row);
+  }
+
+  sql_COMPARE__##CMP(NAME, $parmc )
+
+---
+print OUT &prepare($out);
+
+#
+# short cut defs
+#
+
+print OUT << "---";
+#define sql_create_$i(NAME, CMP, CONTR, $parm_simple) \\
+  sql_create_complete_$i(NAME, CMP, CONTR, $parm_simple2c) \\
+
+// ---------------------------------------------------
+//                  End Create $i
+// ---------------------------------------------------
+
+---
+
+}
+
+
+print OUT << "---";
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_SSQLS_H)
+
+---
+
+
+sub prepare {
+    local $_ = $_[0];
+    s/\n+$//;
+    s/\n[\n ]*\n/\n/g; 
+    s/\n+/\\\n/g;
+    $_ .= "\n\n";
+    return $_;
+}
+

ADDED   lib/stadapter.cpp
Index: lib/stadapter.cpp
==================================================================
--- /dev/null
+++ lib/stadapter.cpp
@@ -0,0 +1,484 @@
+/***********************************************************************
+ stadapter.cpp - Implements the SQLTypeAdapter class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "stadapter.h"
+
+#include "mystring.h"
+#include "refcounted.h"
+#include "stream2string.h"
+
+#include <iomanip>
+#include <sstream>
+
+using namespace std;
+
+namespace mysqlpp {
+
+SQLTypeAdapter::SQLTypeAdapter() :
+is_processed_(false)
+{
+}
+
+SQLTypeAdapter::SQLTypeAdapter(const SQLTypeAdapter& other) :
+buffer_(other.buffer_),
+is_processed_(false)
+{
+}
+
+SQLTypeAdapter::SQLTypeAdapter(const String& other, bool processed) :
+buffer_(other.buffer_),
+is_processed_(processed)
+{
+}
+
+SQLTypeAdapter::SQLTypeAdapter(const std::string& str, bool processed) :
+buffer_(new SQLBuffer(str, mysql_type_info::string_type, false)),
+is_processed_(processed)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(const Null<string>& str, bool processed) :
+buffer_(new SQLBuffer(str.is_null ? null_str : str.data,
+		str.is_null ? typeid(void) : typeid(str.data), str.is_null)),
+is_processed_(processed)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(const char* str, bool processed) : 
+buffer_(new SQLBuffer(str, strlen(str), mysql_type_info::string_type, false)),
+is_processed_(processed)
+{
+}
+
+SQLTypeAdapter::SQLTypeAdapter(const char* str, int len, bool processed) : 
+buffer_(new SQLBuffer(str, len, mysql_type_info::string_type, false)),
+is_processed_(processed)
+{
+}
+
+SQLTypeAdapter::SQLTypeAdapter(char c) :
+buffer_(new SQLBuffer(stream2string(c), mysql_type_info::string_type, false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<char> c) :
+buffer_(new SQLBuffer(c.is_null ? null_str : stream2string(c),
+		c.is_null ? typeid(void) : typeid(c.data), c.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(sql_tinyint i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<sql_tinyint> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(sql_tinyint_unsigned i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<sql_tinyint_unsigned> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(short i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<short> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(unsigned short i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<unsigned short> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(int i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<int> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(unsigned i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<unsigned> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(long i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<long> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(unsigned long i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<unsigned long> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(longlong i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false)
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<longlong> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false)
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(ulonglong i) :
+buffer_(new SQLBuffer(stream2string(i), typeid(i), false)),
+is_processed_(false) 
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<ulonglong> i) :
+buffer_(new SQLBuffer(i.is_null ? null_str : stream2string(i),
+		i.is_null ? typeid(void) : typeid(i.data), i.is_null)),
+is_processed_(false) 
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(float f) :
+is_processed_(false)
+{
+	ostringstream outs;
+	outs.precision(9);	// max dec digits needed for IEEE 754 32-bit float
+	outs << f;
+	buffer_ = new SQLBuffer(outs.str(), typeid(f), false);
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<float> f) :
+is_processed_(false)
+{
+	if (f.is_null) {
+		buffer_ = new SQLBuffer(null_str, typeid(void), true);
+	}
+	else {
+		ostringstream outs;
+		outs.precision(9);	// as above
+		outs << f;
+		buffer_ = new SQLBuffer(outs.str(), typeid(f.data), false);
+	}
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(double f) :
+is_processed_(false)
+{
+	ostringstream outs;
+	outs.precision(17);	// max dec digits needed for IEEE 754 64-bit float
+	outs << f;
+	buffer_ = new SQLBuffer(outs.str(), typeid(f), false);
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(Null<double> f) :
+is_processed_(false)
+{
+	if (f.is_null) {
+		buffer_ = new SQLBuffer(null_str, typeid(void), true);
+	}
+	else {
+		ostringstream outs;
+		outs.precision(17);	// as above
+		outs << f;
+		buffer_ = new SQLBuffer(outs.str(), typeid(f.data), false);
+	}
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(const Date& d) :
+buffer_(new SQLBuffer(stream2string(d), typeid(d), false)),
+is_processed_(false) 
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(const Null<Date>& d) :
+buffer_(new SQLBuffer(d.is_null ? null_str : stream2string(d),
+		d.is_null ? typeid(void) : typeid(d.data), d.is_null)),
+is_processed_(false) 
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(const DateTime& dt) :
+buffer_(new SQLBuffer(stream2string(dt), typeid(dt), false)),
+is_processed_(false) 
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(const Null<DateTime>& dt) :
+buffer_(new SQLBuffer(dt.is_null ? null_str : stream2string(dt),
+		dt.is_null ? typeid(void) : typeid(dt.data), dt.is_null)),
+is_processed_(false) 
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(const Time& t) :
+buffer_(new SQLBuffer(stream2string(t), typeid(t), false)),
+is_processed_(false) 
+{
+}
+
+#if !defined(DOXYGEN_IGNORE)
+SQLTypeAdapter::SQLTypeAdapter(const Null<Time>& t) :
+buffer_(new SQLBuffer(t.is_null ? null_str : stream2string(t),
+		t.is_null ? typeid(void) : typeid(t.data), t.is_null)),
+is_processed_(false) 
+{
+}
+#endif
+
+SQLTypeAdapter::SQLTypeAdapter(const null_type&) :
+buffer_(new SQLBuffer(null_str, typeid(void), true)),
+is_processed_(false)
+{
+}
+
+SQLTypeAdapter&
+SQLTypeAdapter::assign(const SQLTypeAdapter& sta)
+{
+	buffer_ = sta.buffer_;
+	is_processed_ = false;
+	return *this;
+}
+
+SQLTypeAdapter&
+SQLTypeAdapter::assign(const char* pc, int len)
+{
+	if (len < 0) {
+		len = strlen(pc);
+	}
+
+	buffer_ = new SQLBuffer(pc, len, mysql_type_info::string_type, false);
+	is_processed_ = false;
+	return *this;
+}
+
+SQLTypeAdapter&
+SQLTypeAdapter::assign(const null_type&)
+{ 
+	buffer_ = new SQLBuffer(null_str, typeid(void), true);
+	is_processed_ = false;
+	return *this;
+}
+
+char
+SQLTypeAdapter::at(size_type i) const throw(std::out_of_range)
+{
+	if (buffer_) {
+		if (i <= length()) {
+			return *(buffer_->data() + i);
+		}
+		else {
+			throw out_of_range("Not enough chars in SQLTypeAdapter");
+		}
+	}
+	else {
+		throw out_of_range("SQLTypeAdapter buffer not initialized");
+	}
+}
+
+int
+SQLTypeAdapter::compare(const SQLTypeAdapter& other) const
+{
+	if (other.buffer_) {
+		return compare(0, length(), other.buffer_->data());
+	}
+	else {
+		return buffer_ ? 1 : 0;
+	}
+}
+
+int
+SQLTypeAdapter::compare(const std::string& other) const
+{
+	return compare(0, length(), other.data());
+}
+
+int
+SQLTypeAdapter::compare(size_type pos, size_type num, 
+		std::string& other) const
+{
+	return compare(pos, num, other.data());
+}
+
+int
+SQLTypeAdapter::compare(const char* other) const
+{
+	return compare(0, length(), other);
+}
+
+int
+SQLTypeAdapter::compare(size_type pos, size_type num,
+		const char* other) const
+{
+	if (buffer_ && other) {
+		return strncmp(data() + pos, other, num);
+	}
+	else if (!other) {
+		return 1;				// initted is "greater than" uninitted
+	}
+	else {
+		return other ? -1 : 0;	// "less than" unless other also unitted
+	}
+}
+
+const char*
+SQLTypeAdapter::data() const
+{
+	return buffer_ ? buffer_->data() : 0;
+}
+
+SQLTypeAdapter::size_type
+SQLTypeAdapter::length() const
+{
+	return buffer_ ? buffer_->length() : 0;
+}
+
+bool
+SQLTypeAdapter::escape_q() const
+{
+	return buffer_ ? buffer_->escape_q() : false;
+}
+
+SQLTypeAdapter&
+SQLTypeAdapter::operator =(const SQLTypeAdapter& rhs)
+{
+	return assign(rhs);
+}
+
+SQLTypeAdapter&
+SQLTypeAdapter::operator =(const null_type& n)
+{ 
+	return assign(n);
+}
+
+bool
+SQLTypeAdapter::quote_q() const
+{
+	// If no buffer, it means we're an empty string, so we need to be 
+	// quoted to be expressed properly in SQL.
+	return buffer_ ? buffer_->quote_q() : true;
+}
+
+int
+SQLTypeAdapter::type_id() const
+{
+	return buffer_ ? buffer_->type().id() : 0;
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/stadapter.h
Index: lib/stadapter.h
==================================================================
--- /dev/null
+++ lib/stadapter.h
@@ -0,0 +1,325 @@
+/// \file stadapter.h
+/// \brief Declares the SQLTypeAdapter class
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_SQL_TYPE_ADAPTER_H)
+#define MYSQLPP_SQL_TYPE_ADAPTER_H
+
+#include "common.h"
+
+#include "datetime.h"
+#include "null.h"
+#include "sql_buffer.h"
+#include "sql_types.h"
+
+#include <stdexcept>
+#include <string>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+class MYSQLPP_EXPORT String;
+#endif
+
+/// \brief Converts many different data types to strings suitable for
+/// use in SQL queries.
+///
+/// This class provides implicit conversion between many C++ types and
+/// SQL-formatted string representations of that data without losing
+/// important type information.  This class is not for direct use
+/// outside MySQL++ itself.  It exists for those interfaces in MySQL++
+/// that need to accept a value of any reasonable data type which it
+/// will use in building a query string.
+///
+/// One major use for this is in the Query class interfaces for building
+/// template queries: they have to be generic with respect to argument
+/// type, but because we know we want the data in some kind of string
+/// form eventually, we don't need to templatize it. The interface can 
+/// just use SQLTypeAdapter, which lets callers pass any reasonable data
+/// type. The adapter converts the passed value implicitly.
+///
+/// The other major use for this type is the quoting and escaping logic
+/// in Query's stream interface: rather than overload the << operators
+/// and the manipulators for every single type we know the rules for \e a 
+/// \e priori, we just specialize the manipulators for SQLTypeAdapter.
+/// The conversion to SQLTypeAdapter stringizes the data, which we needed
+/// anyway for stream insertion, and holds enough type information so
+/// that the manipulator can decide whether to do automatic quoting
+/// and/or escaping.
+
+class MYSQLPP_EXPORT SQLTypeAdapter
+{
+public:
+	typedef size_t size_type;	///< size of length values
+
+	/// \brief Default constructor; empty string
+	SQLTypeAdapter();
+
+	/// \brief Copy ctor
+	///
+	/// \param other the other SQLTypeAdapter object
+	///
+	/// This ctor only copies the pointer to the other SQLTypeAdapter's
+	/// data buffer and increments its reference counter.  If you need a
+	/// deep copy, use one of the ctors that takes a string.
+	SQLTypeAdapter(const SQLTypeAdapter& other);
+
+	/// \brief Create a copy of a MySQL++ string
+	///
+	/// This does reference-counted buffer sharing with the other 
+	/// object.  If you need a deep copy, pass the result of 
+	/// either String::c_str() or String::conv() instead, which will 
+	/// call one of the other string ctors.
+	SQLTypeAdapter(const String& str, bool processed = false);
+
+	/// \brief Create a copy of a C++ string
+	SQLTypeAdapter(const std::string& str, bool processed = false);
+
+	/// \brief Create a copy of a null-terminated C string
+	SQLTypeAdapter(const char* str, bool processed = false);
+
+	/// \brief Create a copy of an arbitrary block of data
+	SQLTypeAdapter(const char* str, int len, bool processed = false);
+
+	/// \brief Create a single-character string
+	///
+	/// If you mean for \c c to be treated as a small integer, you
+	/// should be using mysqlpp::tiny_int instead.  It avoids the
+	/// confusion in C++ between integer and character.  See the
+	/// documentation for tiny_int.h for details.
+	SQLTypeAdapter(char c);
+
+	/// \brief Create a string representation of SQL \c TINYINT
+	SQLTypeAdapter(sql_tinyint i);
+
+	/// \brief Create a string representation of SQL \c TINYINT
+	/// \c UNSIGNED
+	SQLTypeAdapter(sql_tinyint_unsigned i);
+
+	/// \brief Create a string representation of a \c short \c int value
+	SQLTypeAdapter(short i);
+
+	/// \brief Create a string representation of an \c unsigned
+	/// \c short \c int value
+	SQLTypeAdapter(unsigned short i);
+
+	/// \brief Create a string representation of an \c int value
+	SQLTypeAdapter(int i);
+
+	/// \brief Create a string representation of an \c unsigned \c int
+	/// value
+	SQLTypeAdapter(unsigned i);
+
+	/// \brief Create a string representation of a \c long \c int value
+	SQLTypeAdapter(long i);
+
+	/// \brief Create a string representation of an \c unsigned
+	/// \c long \c int value
+	SQLTypeAdapter(unsigned long i);
+
+	/// \brief Create a string representation of a \c longlong value
+	SQLTypeAdapter(longlong i);
+
+	/// \brief Create a string representation of an \c unsigned
+	/// \c longlong value
+	SQLTypeAdapter(ulonglong i);
+
+	/// \brief Create a string representation of a \c float value
+	SQLTypeAdapter(float i);
+
+	/// \brief Create a string representation of a \c double value
+	SQLTypeAdapter(double i);
+
+	/// \brief Create a SQL string representation of a date
+	SQLTypeAdapter(const Date& d);
+
+	/// \brief Create a SQL string representation of a date and time
+	SQLTypeAdapter(const DateTime& dt);
+
+	/// \brief Create a SQL string representation of a time
+	SQLTypeAdapter(const Time& t);
+
+	/// \brief Create object representing SQL NULL
+	SQLTypeAdapter(const null_type& i);
+
+	/// \brief Standard assignment operator
+	///
+	/// \see assign(const SQLTypeAdapter&) for details
+	SQLTypeAdapter& operator =(const SQLTypeAdapter& rhs);
+
+	/// \brief Replace contents of object with a SQL null
+	///
+	/// \see assign(const null_type&) for details
+	SQLTypeAdapter& operator =(const null_type& n);
+
+	/// \brief Returns a const char pointer to the object's raw data
+	operator const char*() const { return data(); }
+
+	/// \brief Copies another SQLTypeAdapter's data buffer into this
+	/// object.
+	///
+	/// \param sta Other object to copy
+	///
+	/// \retval *this
+	///
+	/// Detaches this object from its internal buffer and attaches
+	/// itself to the other object's buffer, with reference counting
+	/// on each side.  If you need a deep copy, call one of the
+	/// assign() overloads taking a C or C++ string instead.
+	SQLTypeAdapter& assign(const SQLTypeAdapter& sta);
+	
+	/// \brief Copies a C string or a raw buffer into this object.
+	///
+	/// \param pc Pointer to char buffer to copy
+	/// \param len Number of characters to copy; default tells function
+	/// to use the return value of strlen() instead.
+	///
+	/// \retval *this
+	///
+	/// If you give the len parameter, this function will treat pc as a
+	/// pointer to an array of char, not as a C string.  It only treats
+	/// null characters as special when you leave len at its default.
+	SQLTypeAdapter& assign(const char* pc, int len = -1);
+
+	/// \brief Replaces contents of object with a SQL null
+	///
+	/// \param n typically, the MySQL++ global object mysqlpp::null
+	///
+	/// \retval *this
+	SQLTypeAdapter& assign(const null_type& n);
+
+	/// \brief Returns the character at a given position within the
+	/// string buffer.
+	///
+	/// \throw out_of_range if the internal buffer is not initialized
+	/// (default ctor called, and no assignment operator subsequently)
+	/// or if there are not at least i + 1 characters in the buffer
+	char at(size_type i) const throw(std::out_of_range);
+
+	/// \brief Compare the internal buffer to the given string
+	///
+	/// Works just like string::compare(const std::string&).
+	int compare(const SQLTypeAdapter& other) const;
+
+	/// \brief Compare the internal buffer to the given string
+	///
+	/// Works just like string::compare(const std::string&).
+	int compare(const std::string& other) const;
+
+	/// \brief Compare the internal buffer to the given string
+	///
+	/// Works just like string::compare(size_type, size_type, 
+	/// std::string&).
+	int compare(size_type pos, size_type num, std::string& other) const;
+
+	/// \brief Compare the internal buffer to the given string
+	///
+	/// Works just like string::compare(const char*).
+	int compare(const char* other) const;
+
+	/// \brief Compare the internal buffer to the given string
+	///
+	/// Works just like string::compare(size_type, size_type, 
+	/// const char*).
+	int compare(size_type pos, size_type num, const char* other) const;
+
+	/// \brief Return pointer to raw data buffer
+	const char* data() const;
+
+	/// \brief Returns true if we were initialized with a data type
+	/// that must be escaped when used in a SQL query
+	bool escape_q() const;
+
+	/// \brief Returns true if the internal 'processed' flag is set.
+	///
+	/// This is an implementation detail of template queries, used to
+	/// prevent repeated processing of values.
+	bool is_processed() const { return is_processed_; }
+
+	/// \brief Return number of bytes in data buffer
+	size_type length() const;
+	size_type size() const { return length(); } ///< alias for length()
+
+	/// \brief Returns true if we were initialized with a data type
+	/// that must be quoted when used in a SQL query
+	bool quote_q() const;
+
+	/// \brief Returns the type ID of the buffer's data
+	///
+	/// Values from type_info.h.  At the moment, these are the same as
+	/// the underlying MySQL C API type IDs, but it's not a good idea
+	/// to count on this remaining the case.
+	int type_id() const;
+
+	/// \brief Turns on the internal 'is_processed_' flag.
+	///
+	/// This is an implementation detail of template queries, used to
+	/// prevent repeated processing of values.
+	void set_processed() { is_processed_ = true; }
+
+#if !defined(DOXYGEN_IGNORE)
+	// Parallel interface for Null<>-wrapped versions of types we
+	// support above.  No need for parallel documentation.
+	SQLTypeAdapter(const Null<std::string>& str, bool processed = false);
+	SQLTypeAdapter(Null<char> c);
+	SQLTypeAdapter(Null<sql_tinyint> i);
+	SQLTypeAdapter(Null<sql_tinyint_unsigned> i);
+	SQLTypeAdapter(Null<short> i);
+	SQLTypeAdapter(Null<unsigned short> i);
+	SQLTypeAdapter(Null<int> i);
+	SQLTypeAdapter(Null<unsigned> i);
+	SQLTypeAdapter(Null<long> i);
+	SQLTypeAdapter(Null<unsigned long> i);
+	SQLTypeAdapter(Null<longlong> i);
+	SQLTypeAdapter(Null<ulonglong> i);
+	SQLTypeAdapter(Null<float> i);
+	SQLTypeAdapter(Null<double> i);
+	SQLTypeAdapter(const Null<Date>& d);
+	SQLTypeAdapter(const Null<DateTime>& dt);
+	SQLTypeAdapter(const Null<Time>& t);
+	SQLTypeAdapter& operator =(const Null<std::string>& str);
+#endif // !defined(DOXYGEN_IGNORE)
+
+private:
+	/// \brief Our internal string buffer
+	RefCountedBuffer buffer_;
+
+	/// \brief If true, one of the MySQL++ manipulators has processed
+	/// the string data.
+	///
+	/// "Processing" is escaping special SQL characters, and/or adding
+	/// quotes.  See the documentation for manip.h for details.
+	///
+	/// This flag is used by the template query mechanism, to prevent a
+	/// string from being re-escaped or re-quoted each time that query
+	/// is reused.  The flag is reset by operator=, to force the new
+	/// parameter value to be re-processed.
+	bool is_processed_;
+};
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_SQL_TYPE_ADAPTER_H)

ADDED   lib/stream2string.h
Index: lib/stream2string.h
==================================================================
--- /dev/null
+++ lib/stream2string.h
@@ -0,0 +1,51 @@
+/// \file stream2string.h
+/// \brief Declares an adapter that converts something that can be
+/// inserted into a C++ stream into a std::string type.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_STREAM2STRING_H)
+#define MYSQLPP_STREAM2STRING_H
+
+#include <sstream>
+#include <string>
+
+namespace mysqlpp {
+
+/// \brief Converts anything you can insert into a C++ stream to a
+/// \c std::string via \c std::ostringstream.
+
+template <class T>
+std::string stream2string(const T& object)
+{
+	std::ostringstream str;
+	str << object;
+	return str.str();
+}
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_STREAM2STRING_H)
+

ADDED   lib/tcp_connection.cpp
Index: lib/tcp_connection.cpp
==================================================================
--- /dev/null
+++ lib/tcp_connection.cpp
@@ -0,0 +1,158 @@
+/***********************************************************************
+ tcp_connection.cpp - Implements the TCPConnection class.
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "common.h"
+#include "tcp_connection.h"
+
+#include "exceptions.h"
+
+#if !defined(MYSQLPP_PLATFORM_WINDOWS)
+#	include <netdb.h>
+#endif
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <climits>
+
+using namespace std;
+
+namespace mysqlpp {
+
+
+bool
+TCPConnection::connect(const char* addr, const char* db,
+		const char* user, const char* pass)
+{
+	error_message_.clear();
+
+	unsigned int port = 0;
+	string address;
+	if (addr) {
+		address = addr;
+		if (!parse_address(address, port, error_message_)) {
+			return false;
+		}
+	}
+
+	if (error_message_.empty()) {
+		return Connection::connect(db, address.c_str(), user, pass, port);
+	}
+	else {
+		if (throw_exceptions()) {
+			throw ConnectionFailed(error_message_.c_str());
+		}
+		else {
+			return false;
+		}
+	}
+}
+
+
+bool
+TCPConnection::parse_address(std::string& addr, unsigned int& port,
+		std::string& error)
+{
+	error.clear();
+	
+	// Pull off service name or port number, if any
+	string service;
+	if (addr[0] == '[') {
+		// Might be IPv6 address plus port/service in RFC 2732 form.
+		string::size_type pos = addr.find(']');
+		if ((pos == string::npos) ||
+				(addr.find(':', pos + 1) != (pos + 1)) ||
+				(addr.find_first_of("[]", pos + 2) != string::npos)) {
+			error = "Malformed IPv6 [address]:service combination";
+			return false;
+		}
+
+		// We can separate address from port/service now
+		service = addr.substr(pos + 2);
+		addr = addr.substr(1, pos - 1);
+
+		// Ensure that address part is empty or has at least two colons
+		if (addr.size() &&
+				(((pos = addr.find(':')) == string::npos) ||
+				(addr.find(':', pos + 1) == string::npos))) {
+			error = "IPv6 literal needs at least two colons";
+			return false;
+		}
+	}
+	else {
+		// Can only be IPv4 address, so check for 0-1 colons
+		string::size_type pos = addr.find(':');
+		if (pos != string::npos) {
+			if (addr.find(':', pos + 1) != string::npos) {
+				error = "IPv4 address:service combo can have only one colon";
+				return false;
+			}
+			
+			service = addr.substr(pos + 1);
+			addr = addr.substr(0, pos);
+		}
+	}
+
+	// Turn service into a port number, if it was given.  If not, don't
+	// overwrite port because it could have a legal value passed in from
+	// Connection.
+	if (!service.empty()) {
+		if (isdigit(service[0])) {
+			port = atoi(service.c_str());
+			if ((port < 1) || (port > USHRT_MAX)) {
+				error = "Invalid TCP port number " + service;
+				return false;
+			}
+		}
+		else {
+			servent* pse = getservbyname(service.c_str(), "tcp");
+			if (pse) {
+				port = ntohs(pse->s_port);
+			}
+			else {
+				error = "Failed to look up TCP service " + service;
+				return false;
+			}
+		}
+	}
+
+	// Ensure that there are only alphanumeric characters, dots,
+	// dashes and colons in address.  Anything else must be an error.
+	for (string::const_iterator it = addr.begin(); it != addr.end(); ++it) {
+		string::value_type c = *it;
+		if (!(isalnum(c) || (c == '.') || (c == '-') || (c == ':'))) {
+			error = "Bad character '";
+			error += c;
+			error += "' in TCP/IP address";
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+} // end namespace mysqlpp
+

ADDED   lib/tcp_connection.h
Index: lib/tcp_connection.h
==================================================================
--- /dev/null
+++ lib/tcp_connection.h
@@ -0,0 +1,127 @@
+/// \file tcp_connection.h
+/// \brief Declares the TCPConnection class.
+
+/***********************************************************************
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_TCP_CONNECTION_H)
+#define MYSQLPP_TCP_CONNECTION_H
+
+#include "connection.h"
+
+namespace mysqlpp {
+
+/// \brief Specialization of \c Connection for TCP/IP
+///
+/// This class just simplifies the connection creation interface of
+/// \c Connection.  It does not add new functionality.
+
+class MYSQLPP_EXPORT TCPConnection : public Connection
+{
+public:
+	/// \brief Create object without connecting it to the MySQL server.
+	TCPConnection() :
+	Connection()
+	{
+	}
+
+	/// \brief Create object and connect to database server over TCP/IP
+	/// in one step.
+	///
+	/// \param addr TCP/IP address of server, in either dotted quad form
+	///     or as a host or domain name; may be followed by a colon and
+	///     a port number or service name to override default port
+	/// \param db name of database to use
+	/// \param user user name to log in under, or 0 to use the user
+	///		name the program is running under
+	/// \param password password to use when logging in
+	///
+	/// \b BEWARE: These parameters are not in the same order as those
+	/// in the corresponding constructor for Connection.  This is a
+	/// feature, not a bug. :)
+	TCPConnection(const char* addr, const char* db = 0, const char* user = 0,
+			const char* password = 0) :
+	Connection()
+	{
+		connect(addr, db, user, password);
+	}
+
+	/// \brief Establish a new connection using the same parameters as
+	/// an existing connection.
+	///
+	/// \param other pre-existing connection to clone
+	TCPConnection(const TCPConnection& other) :
+	Connection(other)
+	{
+	}
+
+	/// \brief Destroy object
+	~TCPConnection() { }
+
+	/// \brief Connect to database after object is created.
+	///
+	/// It's better to use the connect-on-create constructor if you can.
+	/// See its documentation for the meaning of these parameters.
+	///
+	/// If you call this method on an object that is already connected
+	/// to a database server, the previous connection is dropped and a
+	/// new connection is established.
+	bool connect(const char* addr = 0, const char* db = 0,
+			const char* user = 0, const char* password = 0);
+
+	/// \brief Break the given TCP/IP address up into a separate address
+	/// and port form
+	///
+	/// Does some sanity checking on the address.  Only intended to
+	/// try and prevent library misuse, not ensure that the address can
+	/// actually be used to contact a server.
+	///
+	/// It understands the following forms:
+	///
+	///	- 1.2.3.4
+	///
+	/// - a.b.com:89
+	///
+	/// - d.e.fr:mysvcname
+	///
+	/// It also understands IPv6 addresses, but to avoid confusion
+	/// between the colons they use and the colon separating the address
+	/// part from the service/port part, they must be in RFC 2732 form.
+	/// Example: \c [2010:836B:4179::836B:4179]:1234
+	///
+	/// \param addr the address and optional port/service combo to check
+	/// on input, and the verified address on successful return
+	/// \param port the port number (resolved from the service name if
+	/// necessary) on successful return
+	/// \param error on false return, reason for failure is placed here
+	///
+	/// \return false if address fails to pass sanity checks
+	static bool parse_address(std::string& addr, unsigned int& port,
+			std::string& error);
+};
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_TCP_CONNECTION_H)
+

ADDED   lib/tiny_int.h
Index: lib/tiny_int.h
==================================================================
--- /dev/null
+++ lib/tiny_int.h
@@ -0,0 +1,275 @@
+/// \file tiny_int.h
+/// \brief Declares class for holding a SQL TINYINT
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_TINY_INT_H)
+#define MYSQLPP_TINY_INT_H
+
+#include "common.h"
+
+#include <ostream>
+
+namespace mysqlpp {
+
+/// \brief Class for holding an SQL \c TINYINT value
+///
+/// This is required because the closest C++ type, \c char, doesn't
+/// have all the right semantics.  For one, inserting a \c char into a
+/// stream won't give you a number.  For another, if you don't specify
+/// signedness explicitly, C++ doesn't give a default, so it's signed
+/// on some platforms, unsigned on others.
+///
+/// The template parameter is intended to allow instantiating it as
+/// tiny_int<unsigned char> to hold \c TINYINT \c UNSIGNED values.
+/// There's nothing stopping you from using any other integer type if
+/// you want to be perverse, but please don't do that.
+///
+/// Several of the functions below accept an \c int argument, but
+/// internally we store the data as a \c char by default. Beware of
+/// integer overflows!
+
+template <typename VT = signed char>
+class tiny_int
+{
+public:
+	//// Type aliases
+	typedef tiny_int<VT> this_type;	///< alias for this object's type
+	typedef VT value_type;			///< alias for type of internal value
+
+	/// \brief Default constructor
+	///
+	/// Value is uninitialized
+	tiny_int() { }
+	
+	/// \brief Create object from any integral type that can be
+	/// converted to a \c short \c int.
+	tiny_int(value_type v) :
+	value_(value_type(v))
+	{
+	}
+	
+	/// \brief Return truthiness of value
+	operator bool() const
+	{
+		return value_;
+	}
+
+	/// \brief Return value as an \c int.
+	operator int() const
+	{
+		return static_cast<int>(value_);
+	}
+
+	/// \brief Return raw data value with no size change
+	operator value_type() const
+	{
+		return value_;
+	}
+
+	/// \brief Assign a new value to the object.
+	this_type& operator =(int v)
+	{
+		value_ = static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Add another value to this object
+	this_type& operator +=(int v)
+	{
+		value_ += static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Subtract another value to this object
+	this_type& operator -=(int v)
+	{
+		value_ -= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Multiply this value by another object
+	this_type& operator *=(int v)
+	{
+		value_ *= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Divide this value by another object
+	this_type& operator /=(int v)
+	{
+		value_ /= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Divide this value by another object and store the
+	/// remainder
+	this_type& operator %=(int v)
+	{
+		value_ %= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Bitwise AND this value by another value
+	this_type& operator &=(int v)
+	{
+		value_ &= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Bitwise OR this value by another value
+	this_type& operator |=(int v)
+	{
+		value_ |= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Bitwise XOR this value by another value
+	this_type& operator ^=(int v)
+	{
+		value_ ^= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Shift this value left by \c v positions
+	this_type& operator <<=(int v)
+	{
+		value_ <<= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Shift this value right by \c v positions
+	this_type& operator >>=(int v)
+	{
+		value_ >>= static_cast<value_type>(v);
+		return *this;
+	}
+
+	/// \brief Add one to this value and return that value
+	this_type& operator ++()
+	{
+		++value_;
+		return *this;
+	}
+
+	/// \brief Subtract one from this value and return that value
+	this_type& operator --()
+	{
+		--value_;
+		return *this;
+	}
+
+	/// \brief Add one to this value and return the previous value
+	this_type operator ++(int)
+	{
+		this_type tmp = value_;
+		++value_;
+		return tmp;
+	}
+
+	/// \brief Subtract one from this value and return the previous
+	/// value
+	this_type operator --(int)
+	{
+		this_type tmp = value_;
+		--value_;
+		return tmp;
+	}
+
+	/// \brief Return this value minus \c i
+	this_type operator -(const this_type& i) const
+	{
+		return value_ - i.value_;
+	}
+	
+	/// \brief Return this value plus \c i
+	this_type operator +(const this_type& i) const
+	{
+		return value_ + i.value_;
+	}
+	
+	/// \brief Return this value multiplied by \c i
+	this_type operator *(const this_type& i) const
+	{
+		return value_ * i.value_;
+	}
+	
+	/// \brief Return this value divided by \c i
+	this_type operator /(const this_type& i) const
+	{
+		return value_ / i.value_;
+	}
+	
+	/// \brief Return the modulus of this value divided by \c i
+	this_type operator %(const this_type& i) const
+	{
+		return value_ % i.value_;
+	}
+	
+	/// \brief Return this value bitwise OR'd by \c i
+	this_type operator |(const this_type& i) const
+	{
+		return value_ | i.value_;
+	}
+	
+	/// \brief Return this value bitwise AND'd by \c i
+	this_type operator &(const this_type& i) const
+	{
+		return value_ & i.value_;
+	}
+	
+	/// \brief Return this value bitwise XOR'd by \c i
+	this_type operator ^(const this_type& i) const
+	{
+		return value_ ^ i.value_;
+	}
+	
+	/// \brief Return this value bitwise shifted left by \c i
+	this_type operator <<(const this_type& i) const
+	{
+		return value_ << i.value_;
+	}
+	
+	/// \brief Return this value bitwise shifted right by \c i
+	this_type operator >>(const this_type& i) const
+	{
+		return value_ >> i.value_;
+	}
+
+private:
+	value_type value_;
+};
+
+/// \brief Insert a \c tiny_int into a C++ stream
+template <typename VT>
+std::ostream& operator <<(std::ostream& os, tiny_int<VT> i)
+{
+	os << static_cast<int>(i);
+	return os;
+}
+
+} // end namespace mysqlpp
+
+#endif

ADDED   lib/transaction.cpp
Index: lib/transaction.cpp
==================================================================
--- /dev/null
+++ lib/transaction.cpp
@@ -0,0 +1,90 @@
+/***********************************************************************
+ transaction.cpp - Implements the Transaction class.
+
+ Copyright (c) 2006-2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "common.h"
+
+#include "transaction.h"
+
+#include "connection.h"
+#include "query.h"
+
+using namespace std;
+using namespace mysqlpp;
+
+
+//// ctor //////////////////////////////////////////////////////////////
+
+Transaction::Transaction(Connection& conn, bool consistent) :
+conn_(conn),
+finished_(true)		// don't bother rolling it back if ctor fails
+{
+	// Begin the transaction set
+	Query q(conn_.query("START TRANSACTION"));
+	if (consistent) {
+		q << " WITH CONSISTENT SNAPSHOT";
+	}
+	q.execute();
+
+	// Setup succeeded, so mark our transaction as not-finished.
+	finished_ = false;
+}
+
+
+//// dtor //////////////////////////////////////////////////////////////
+
+Transaction::~Transaction()
+{
+	if (!finished_) {
+		try {
+			rollback();
+		}
+		catch (...) {
+			// eat all exceptions
+		}
+	}
+}
+
+
+//// commit ////////////////////////////////////////////////////////////
+
+void
+Transaction::commit()
+{
+	conn_.query("COMMIT").execute();
+	finished_ = true;
+}
+
+
+//// rollback //////////////////////////////////////////////////////////
+
+void
+Transaction::rollback()
+{
+	conn_.query("ROLLBACK").execute();
+	finished_ = true;
+}
+
+

ADDED   lib/transaction.h
Index: lib/transaction.h
==================================================================
--- /dev/null
+++ lib/transaction.h
@@ -0,0 +1,91 @@
+/// \file transaction.h
+/// \brief Declares the Transaction class.
+///
+/// This object works with the Connection class to automate the use of
+/// MySQL transactions.  It allows you to express these transactions
+/// directly in C++ code instead of sending the raw SQL commands.
+
+/***********************************************************************
+ Copyright (c) 2006 by Educational Technology Resources, Inc.  Others
+ may also hold copyrights on code in this file.  See the CREDITS file
+ in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_TRANSACTION_H)
+#define MYSQLPP_TRANSACTION_H
+
+#include "common.h"
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Make Doxygen ignore this
+class MYSQLPP_EXPORT Connection;
+#endif
+
+/// \brief Helper object for creating exception-safe SQL transactions.
+
+class MYSQLPP_EXPORT Transaction
+{
+public:
+	/// \brief Constructor
+	///
+	/// \param conn The connection we use to manage the transaction set
+	/// \param consistent Whether to use "consistent snapshots" during
+	/// the transaction. See the documentation for "START TRANSACTION"
+	/// in the MySQL manual for more on this.
+	Transaction(Connection& conn, bool consistent = false);
+
+	/// \brief Destructor
+	///
+	/// If the transaction has not been committed or rolled back by the
+	/// time the destructor is called, it is rolled back.  This is the
+	/// right thing because one way this can happen is if the object is
+	/// being destroyed as the stack is unwound to handle an exception.
+	/// In that instance, you certainly want to roll back the
+	/// transaction.
+	~Transaction();
+
+	/// \brief Commits the transaction
+	///
+	/// This commits all updates to the database using the connection
+	/// we were created with since this object was created.  This is a
+	/// no-op if the table isn't stored using a transaction-aware
+	/// storage engine.  See CREATE TABLE in the MySQL manual for
+	/// details.
+	void commit();
+
+	/// \brief Rolls back the transaction
+	///
+	/// This abandons all SQL statements made on the connection since
+	/// this object was created.  This only works on tables stored using
+	/// a transaction-aware storage engine.  See CREATE TABLE in the
+	/// MySQL manual for details.
+	void rollback();
+
+private:
+	Connection& conn_;	///! Connection to send queries through
+	bool finished_;		///! True when we commit or roll back xaction
+};
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_TRANSACTION_H)
+

ADDED   lib/type_info.cpp
Index: lib/type_info.cpp
==================================================================
--- /dev/null
+++ lib/type_info.cpp
@@ -0,0 +1,261 @@
+/***********************************************************************
+ type_info.cpp - Implements the mysql_type_info class.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2007 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "common.h"
+#include "type_info.h"
+
+#include "datetime.h"
+#include "myset.h"
+#include "sql_types.h"
+
+#include <mysql.h>
+
+#include <string>
+
+using namespace std;
+
+namespace mysqlpp {
+
+// This table maps C++ type information to SQL type information.  As you
+// can see, it's intimately tied in with MySQL's type constants, thus the
+// name.  Unlike in earlier versions of MySQL++, this table is the only
+// place with such a dependency.  Everything else abstracts MySQL's
+// type system away by bouncing things through this table.
+//
+// The second half of the table parallels the first, to handle null-able
+// versions of the types in the first half.  This is required because
+// SQL's 'null' concept does not map neatly into the C++ type system, so
+// null-able versions of these types have to have a different C++ type,
+// implemented using the Null template.  See null.h for further details.
+//
+// Types with tf_default set are added to a lookup map in the
+// mysql_type_info_lookup class in order to provide reverse lookup
+// of C++ types to SQL types.  If you take the subset of all items
+// marked as default, the typeid() of each item must be unique.
+const mysql_type_info::sql_type_info mysql_type_info::types[] = {
+	sql_type_info("DECIMAL NOT NULL", typeid(sql_decimal),
+#if MYSQL_VERSION_ID >= 50001
+			MYSQL_TYPE_NEWDECIMAL
+#else
+			MYSQL_TYPE_DECIMAL
+#endif
+			),
+	sql_type_info("TINYINT NOT NULL", typeid(sql_tinyint),
+			MYSQL_TYPE_TINY, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("TINYINT UNSIGNED NOT NULL", typeid(sql_tinyint_unsigned),
+			MYSQL_TYPE_TINY, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("SMALLINT NOT NULL", typeid(sql_smallint), 
+			MYSQL_TYPE_SHORT, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("SMALLINT UNSIGNED NOT NULL", typeid(sql_smallint_unsigned), 
+			MYSQL_TYPE_SHORT, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("INT NOT NULL", typeid(sql_int), 
+			MYSQL_TYPE_LONG, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("INT UNSIGNED NOT NULL", typeid(sql_int_unsigned), 
+			MYSQL_TYPE_LONG, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("FLOAT NOT NULL", typeid(sql_float), 
+			MYSQL_TYPE_FLOAT, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("DOUBLE NOT NULL", typeid(sql_double), 
+			MYSQL_TYPE_DOUBLE, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("NULL NOT NULL", typeid(void),
+			MYSQL_TYPE_NULL, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("TIMESTAMP NOT NULL", typeid(sql_timestamp), 
+			MYSQL_TYPE_TIMESTAMP),
+	sql_type_info("BIGINT NOT NULL", typeid(sql_bigint), 
+			MYSQL_TYPE_LONGLONG, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("BIGINT UNSIGNED NOT NULL", typeid(sql_bigint_unsigned), 
+			MYSQL_TYPE_LONGLONG, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("MEDIUMINT NOT NULL", typeid(sql_mediumint), 
+			MYSQL_TYPE_INT24, mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("MEDIUMINT UNSIGNED NOT NULL", typeid(sql_mediumint_unsigned), 
+			MYSQL_TYPE_INT24, mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("DATE NOT NULL", typeid(sql_date), 
+			MYSQL_TYPE_DATE, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("TIME NOT NULL", typeid(sql_time), 
+			MYSQL_TYPE_TIME, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("DATETIME NOT NULL", typeid(sql_datetime), 
+			MYSQL_TYPE_DATETIME, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("ENUM NOT NULL", typeid(sql_enum), 
+			MYSQL_TYPE_ENUM, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("SET NOT NULL", typeid(sql_set), 
+			MYSQL_TYPE_SET, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("TINYBLOB NOT NULL", typeid(sql_tinyblob), 
+			MYSQL_TYPE_TINY_BLOB),
+	sql_type_info("MEDIUMBLOB NOT NULL", typeid(sql_mediumblob), 
+			MYSQL_TYPE_MEDIUM_BLOB),
+	sql_type_info("LONGBLOB NOT NULL", typeid(sql_longblob), 
+			MYSQL_TYPE_LONG_BLOB),
+	sql_type_info("BLOB NOT NULL", typeid(sql_blob), 
+			MYSQL_TYPE_BLOB),
+	sql_type_info("VARCHAR NOT NULL", typeid(sql_varchar), 
+			MYSQL_TYPE_VAR_STRING, mysql_ti_sql_type_info::tf_default),
+	sql_type_info("CHAR NOT NULL", typeid(sql_char), 
+			MYSQL_TYPE_STRING),
+
+	sql_type_info("DECIMAL NULL", typeid(Null<sql_decimal>), 
+#if MYSQL_VERSION_ID >= 50001
+			MYSQL_TYPE_NEWDECIMAL
+#else
+			MYSQL_TYPE_DECIMAL
+#endif
+			, mysql_ti_sql_type_info::tf_null),
+	sql_type_info("TINYINT NULL", typeid(Null<sql_tinyint>), 
+			MYSQL_TYPE_TINY, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("TINYINT UNSIGNED NULL", typeid(Null<sql_tinyint_unsigned>), 
+			MYSQL_TYPE_TINY, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("SMALLINT NULL", typeid(Null<sql_smallint>), 
+			MYSQL_TYPE_SHORT, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("SMALLINT UNSIGNED NULL", typeid(Null<sql_smallint_unsigned>), 
+			MYSQL_TYPE_SHORT, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("INT NULL", typeid(Null<sql_int>), 
+			MYSQL_TYPE_LONG, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("INT UNSIGNED NULL", typeid(Null<sql_int_unsigned>), 
+			MYSQL_TYPE_LONG, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("FLOAT NULL", typeid(Null<sql_float>), 
+			MYSQL_TYPE_FLOAT, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("DOUBLE NULL", typeid(Null<sql_double>), 
+			MYSQL_TYPE_DOUBLE, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("NULL NULL", typeid(Null<void>), 
+			MYSQL_TYPE_NULL, mysql_ti_sql_type_info::tf_null),
+	sql_type_info("TIMESTAMP NULL", typeid(Null<sql_timestamp>), 
+			MYSQL_TYPE_TIMESTAMP),
+	sql_type_info("BIGINT NULL", typeid(Null<sql_bigint>), 
+			MYSQL_TYPE_LONGLONG, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("BIGINT UNSIGNED NULL", typeid(Null<sql_bigint_unsigned>), 
+			MYSQL_TYPE_LONGLONG, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("MEDIUMINT NULL", typeid(Null<sql_mediumint>), 
+			MYSQL_TYPE_INT24, mysql_ti_sql_type_info::tf_null),
+	sql_type_info("MEDIUMINT UNSIGNED NULL", typeid(Null<sql_mediumint_unsigned>), 
+			MYSQL_TYPE_INT24, mysql_ti_sql_type_info::tf_null |
+			mysql_ti_sql_type_info::tf_unsigned),
+	sql_type_info("DATE NULL", typeid(Null<sql_date>), 
+			MYSQL_TYPE_DATE, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("TIME NULL", typeid(Null<sql_time>), 
+			MYSQL_TYPE_TIME, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("DATETIME NULL", typeid(Null<sql_datetime>), 
+			MYSQL_TYPE_DATETIME, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("ENUM NULL", typeid(Null<sql_enum>), 
+			MYSQL_TYPE_ENUM, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("SET NULL", typeid(Null<sql_set>), 
+			MYSQL_TYPE_SET, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("TINYBLOB NULL", typeid(Null<sql_tinyblob>), 
+			MYSQL_TYPE_TINY_BLOB, mysql_ti_sql_type_info::tf_null),
+	sql_type_info("MEDIUMBLOB NULL", typeid(Null<sql_mediumblob>), 
+			MYSQL_TYPE_MEDIUM_BLOB, mysql_ti_sql_type_info::tf_null),
+	sql_type_info("LONGBLOB NULL", typeid(Null<sql_longblob>), 
+			MYSQL_TYPE_LONG_BLOB, mysql_ti_sql_type_info::tf_null),
+	sql_type_info("BLOB NULL", typeid(Null<sql_blob>), 
+			MYSQL_TYPE_BLOB, mysql_ti_sql_type_info::tf_null),
+	sql_type_info("VARCHAR NULL", typeid(Null<sql_varchar>), 
+			MYSQL_TYPE_VAR_STRING, mysql_ti_sql_type_info::tf_default |
+			mysql_ti_sql_type_info::tf_null),
+	sql_type_info("CHAR NULL", typeid(Null<sql_char>), 
+			MYSQL_TYPE_STRING, mysql_ti_sql_type_info::tf_null)
+};
+
+const int mysql_type_info::num_types =
+		sizeof(mysql_type_info::types) / sizeof(mysql_type_info::types[0]);
+
+const mysql_type_info::sql_type_info_lookup
+		mysql_type_info::lookups(mysql_type_info::types,
+		mysql_type_info::num_types);
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+mysql_ti_sql_type_info_lookup::mysql_ti_sql_type_info_lookup(
+		const sql_type_info types[], const int size)
+{
+	for (int i = 0; i < size; ++i) {
+		if (types[i].is_default()) {
+			map_[types[i].c_type_] = i;
+		}
+	}
+}
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+unsigned char mysql_type_info::type(enum_field_types t,
+		bool _unsigned, bool _null) 
+{
+	for (unsigned char i = 0; i < num_types; ++i) {
+		if ((types[i].base_type_ == t) &&
+				(!_unsigned || types[i].is_unsigned()) &&
+				(!_null || types[i].is_null())) {
+			return i;
+		}
+	}
+
+	return type(MYSQL_TYPE_STRING, false, _null);	// punt!
+}
+
+bool mysql_type_info::quote_q() const
+{
+	const type_info& ti = base_type().c_type();
+	return ti == typeid(string) ||
+			ti == typeid(sql_date) ||
+			ti == typeid(sql_time) ||
+			ti == typeid(sql_datetime) ||
+			ti == typeid(sql_set);
+}
+
+bool mysql_type_info::escape_q() const
+{
+	const type_info& ti = c_type();
+	return ti == typeid(string) ||
+			ti == typeid(sql_enum) ||
+			ti == typeid(sql_blob) ||
+			ti == typeid(sql_tinyblob) ||
+			ti == typeid(sql_mediumblob) ||
+			ti == typeid(sql_longblob) ||
+			ti == typeid(sql_char) ||
+			ti == typeid(sql_varchar);
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/type_info.h
Index: lib/type_info.h
==================================================================
--- /dev/null
+++ lib/type_info.h
@@ -0,0 +1,358 @@
+/// \file type_info.h
+/// \brief Declares classes that provide an interface between the SQL
+/// and C++ type systems.
+///
+/// These classes are mostly used internal to the library.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
+ (c) 2004-2008 by Educational Technology Resources, Inc.  Others may
+ also hold copyrights on code in this file.  See the CREDITS file in
+ the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_TYPE_INFO_H)
+#define MYSQLPP_TYPE_INFO_H
+
+#include "common.h"
+
+#include "exceptions.h"
+
+#include <map>
+#include <sstream>
+#include <typeinfo>
+
+namespace mysqlpp {
+
+#if !defined(DOXYGEN_IGNORE)
+// Doxygen will not generate documentation for this section.
+
+class MYSQLPP_EXPORT mysql_type_info;
+class MYSQLPP_EXPORT mysql_ti_sql_type_info_lookup;
+
+class MYSQLPP_EXPORT mysql_ti_sql_type_info
+{
+private:
+	// For use with flags_ bitset
+	enum {
+		tf_default = 1,
+		tf_null = 2,
+		tf_unsigned = 4
+	};
+
+	friend class mysql_type_info;
+	friend class mysql_ti_sql_type_info_lookup;
+
+	mysql_ti_sql_type_info& operator=(
+			const mysql_ti_sql_type_info& b);
+	
+	// Not initting _base_type and _default because only mysql_type_info
+	// can create them.  There *must* be only one copy of each.
+	mysql_ti_sql_type_info() :
+	sql_name_(0),
+	c_type_(0),
+	base_type_(
+#if MYSQL_VERSION_ID > 40000
+		MYSQL_TYPE_NULL
+#else
+		FIELD_TYPE_NULL
+#endif
+	),
+	flags_(0)
+	{
+	}
+	
+	mysql_ti_sql_type_info(const char* s,
+			const std::type_info& t, const enum_field_types bt,
+			const unsigned int flags = 0) :
+	sql_name_(s),
+	c_type_(&t),
+	base_type_(bt),
+	flags_(flags)
+	{
+	}
+
+	bool is_default() const { return flags_ & tf_default; }
+	bool is_null() const { return flags_ & tf_null; }
+	bool is_unsigned() const { return flags_ & tf_unsigned; }
+
+	const char* sql_name_;
+	const std::type_info* c_type_;
+	const enum_field_types base_type_;
+	const unsigned int flags_;
+};
+
+
+struct type_info_cmp
+{
+	bool operator() (const std::type_info* lhs,
+			const std::type_info* rhs) const
+	{
+		return lhs->before(*rhs) != 0;
+	}
+};
+
+class MYSQLPP_EXPORT mysql_ti_sql_type_info_lookup
+{
+private:
+	friend class mysql_type_info;
+
+	typedef mysql_ti_sql_type_info sql_type_info;
+	typedef std::map<const std::type_info*, unsigned char, type_info_cmp>
+			map_type;
+
+	mysql_ti_sql_type_info_lookup(const sql_type_info types[],
+			const int size);
+
+	const unsigned char& operator [](
+			const std::type_info& ti) const
+	{
+		map_type::const_iterator it = map_.find(&ti);
+		if (it != map_.end()) {
+			return it->second;
+		}
+		else {
+			std::ostringstream outs;
+			outs << "Failed to find MySQL C API type ID for " << ti.name();
+			throw TypeLookupFailed(outs.str());
+		}
+	}
+
+	map_type map_;
+};
+
+#endif // !defined(DOXYGEN_IGNORE)
+
+
+/// \brief SQL field type information
+///
+/// \internal Used within MySQL++ for mapping SQL types to C++ types
+/// and vice versa.
+class MYSQLPP_EXPORT mysql_type_info
+{
+public:
+	/// \brief Default constructor
+	///
+	/// This only exists because FieldTypes keeps a vector of these
+	/// objects.  You are expected to copy real values into it before
+	/// using it via the copy ctor or one of the assignment operators.
+	/// If you don't, we have arranged a pretty spectacular crash for
+	/// your program.  So there.
+	mysql_type_info() :
+	num_(static_cast<unsigned char>(-1))
+	{
+	}
+
+	/// \brief Create object from MySQL C API type info
+	///
+	/// \param t the underlying C API type ID for this type
+	/// \param _unsigned if true, this is the unsigned version of the type
+	/// \param _null if true, this type can hold a SQL null
+	mysql_type_info(enum_field_types t, bool _unsigned = false,
+			bool _null = false) :
+	num_(type(t, _unsigned, _null))
+	{
+	}
+
+	/// \brief Create object as a copy of another
+	mysql_type_info(const mysql_type_info& t) :
+	num_(t.num_)
+	{
+	}
+
+	/// \brief Create object from a C++ type_info object
+	///
+	/// This tries to map a C++ type to the closest MySQL data type.
+	/// It is necessarily somewhat approximate.
+	mysql_type_info(const std::type_info& t) :
+	num_(lookups[t])
+	{
+	}
+
+	/// \brief Assign another mysql_type_info object to this object
+	mysql_type_info& operator =(const mysql_type_info& t)
+	{
+		num_ = t.num_;
+		return *this;
+	}
+
+	/// \brief Assign a C++ type_info object to this object
+	///
+	/// This tries to map a C++ type to the closest MySQL data type.
+	/// It is necessarily somewhat approximate.
+	mysql_type_info& operator =(const std::type_info& t)
+	{
+		num_ = lookups[t];
+		return *this;
+	}
+
+	/// \brief Returns an implementation-defined name of the C++ type.
+	///
+	/// Returns the name that would be returned by typeid().name() for
+	/// the C++ type associated with the SQL type.
+	const char* name() const { return deref().c_type_->name(); }
+
+	/// \brief Returns the name of the SQL type.
+	///
+	/// Returns the SQL name for the type.
+	const char* sql_name() const { return deref().sql_name_; }
+
+	/// \brief Returns the type_info for the C++ type associated with
+	/// the SQL type.
+	///
+	/// Returns the C++ type_info record corresponding to the SQL type.
+	const std::type_info& c_type() const { return *deref().c_type_; }
+
+	/// \brief Returns the type_info for the C++ type inside of the
+	/// mysqlpp::Null type.
+	///
+	/// Returns the type_info for the C++ type inside the mysqlpp::Null
+	/// type.  If the type is not Null then this is the same as c_type().
+	const mysql_type_info base_type() const
+	{
+		return mysql_type_info(deref().base_type_);
+	}
+
+	/// \brief Returns the ID of the SQL type.
+	///
+	/// Returns the ID number MySQL uses for this type.  Note: Do not
+	/// depend on the value of this ID as it may change between MySQL
+	/// versions.
+	int id() const
+	{
+		return num_;
+	}
+	
+	/// \brief Returns true if the SQL type is of a type that needs to
+	/// be quoted.
+	///
+	/// \return true if the type needs to be quoted for syntactically
+	/// correct SQL.
+	bool quote_q() const;
+
+	/// \brief Returns true if the SQL type is of a type that needs to
+	/// be escaped.
+	///
+	/// \return true if the type needs to be escaped for syntactically
+	/// correct SQL.
+	bool escape_q() const;
+
+	/// \brief Provides a way to compare two types for sorting.
+	///
+	/// Returns true if the SQL ID of this type is lower than that of
+	/// another.  Used by mysqlpp::type_info_cmp when comparing types.
+	bool before(mysql_type_info& b)
+	{
+		return num_ < b.num_;
+	}
+
+	/// \brief The internal constant we use for our string type.
+	///
+	/// We expose this because other parts of MySQL++ need to know
+	/// what the string constant is at the moment.
+	static const enum_field_types string_type =
+#if MYSQL_VERSION_ID > 40000
+		MYSQL_TYPE_STRING;
+#else
+		FIELD_TYPE_STRING;
+#endif
+
+private:
+	typedef mysql_ti_sql_type_info sql_type_info;
+	typedef mysql_ti_sql_type_info_lookup sql_type_info_lookup;
+
+	static const sql_type_info types[];
+	static const int num_types;
+
+	static const sql_type_info_lookup lookups;
+
+	/// \brief Return an index into mysql_type_info::types array given
+	/// MySQL type information.
+	///
+	/// This function is used in mapping from MySQL type information
+	/// (a type enum, and flags indicating whether it is unsigned and
+	/// whether it can be 'null') to the closest C++ types available
+	/// within MySQL++.  Notice that nulls have to be handled specially:
+	/// the SQL null concept doesn't map directly onto the C++ type
+	/// system.  See null.h for details.
+	///
+	/// \param t Underlying C API type constant
+	/// \param _unsigned if true, indicates the unsigned variant of a
+	/// MySQL type
+	/// \param _null if true, indicates the variant of the MySQL type
+	/// that can also hold an SQL 'null' instead of regular data.
+	///
+	/// While MySQL++ is tied to MySQL, \c t is just an abstraction
+	/// of enum_field_types from mysql_com.h.
+	static unsigned char type(enum_field_types t,
+			bool _unsigned, bool _null = false);
+
+	const sql_type_info& deref() const
+	{
+		return types[num_];
+	}
+
+	unsigned char num_;
+};
+
+/// \brief Returns true if two mysql_type_info objects are equal.
+inline bool operator ==(const mysql_type_info& a, const mysql_type_info& b)
+{
+	return a.id() == b.id();
+}
+
+/// \brief Returns true if two mysql_type_info objects are not equal.
+inline bool operator !=(const mysql_type_info& a, const mysql_type_info& b)
+{
+	return a.id() != b.id();
+}
+
+/// \brief Returns true if a given mysql_type_info object is equal
+/// to a given C++ type_info object.
+inline bool operator ==(const std::type_info& a, const mysql_type_info& b)
+{
+	return a == b.c_type();
+}
+
+/// \brief Returns true if a given mysql_type_info object is not equal
+/// to a given C++ type_info object.
+inline bool operator !=(const std::type_info& a, const mysql_type_info& b)
+{
+	return a != b.c_type();
+}
+
+/// \brief Returns true if a given mysql_type_info object is equal
+/// to a given C++ type_info object.
+inline bool operator ==(const mysql_type_info& a, const std::type_info& b)
+{
+	return a.c_type() == b;
+}
+
+/// \brief Returns true if a given mysql_type_info object is not equal
+/// to a given C++ type_info object.
+inline bool operator !=(const mysql_type_info& a, const std::type_info& b)
+{
+	return a.c_type() != b;
+}
+
+}								// end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_TYPE_INFO_H)
+

ADDED   lib/uds_connection.cpp
Index: lib/uds_connection.cpp
==================================================================
--- /dev/null
+++ lib/uds_connection.cpp
@@ -0,0 +1,120 @@
+/***********************************************************************
+ uds_connection.cpp - Implements the UnixDomainSocketConnection class.
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "common.h"
+#include "uds_connection.h"
+
+#include "exceptions.h"
+
+#if !defined(MYSQLPP_PLATFORM_WINDOWS)
+#	include <unistd.h>
+#	include <sys/stat.h>
+#endif
+
+using namespace std;
+
+namespace mysqlpp {
+
+static const char* common_complaint =
+		"WindowsNamedPipeConnection only works on Windows";
+
+bool
+UnixDomainSocketConnection::connect(const char* path,
+		const char* db, const char* user, const char* pass)
+{
+#if !defined(MYSQLPP_PLATFORM_WINDOWS)
+	if (is_socket(path, &error_message_)) {
+		return Connection::connect(db, path, user, pass);
+	}
+	(void)common_complaint;
+#else
+	error_message_ = common_complaint;
+#endif
+
+	if (throw_exceptions()) {
+		throw ConnectionFailed(error_message_.c_str());
+	}
+	else {
+		return false;
+	}
+}
+
+
+bool
+UnixDomainSocketConnection::is_socket(const char* path, std::string* error)
+{
+#if !defined(MYSQLPP_PLATFORM_WINDOWS)
+	if (path) {
+		struct stat fi;
+
+		if (access(path, F_OK) != 0) {
+			if (error) {
+				*error = path;
+				*error += " does not exist";
+			}
+		}
+		else if (access(path, R_OK | W_OK) != 0) {
+			if (error) {
+				*error = "Don't have read-write permission for ";
+				*error += path;
+			}
+		}
+		else if (stat(path, &fi) != 0) {
+			if (error) {
+				*error = "Failed to get information for ";
+				*error += path;
+			}
+		}
+		else if (!S_ISSOCK(fi.st_mode)) {
+			if (error) {
+				*error = path;
+				*error += " is not a Unix domain socket";
+			}
+		}
+		else {
+			// It's a socket, and we have permission to use it
+			if (error) {
+				error->clear();
+			}
+			return true;
+		}
+	}
+	else 
+#endif
+	if (error) {
+#if !defined(MYSQLPP_PLATFORM_WINDOWS)
+		*error = "NULL is not a valid Unix domain socket";
+#else
+		*error = common_complaint;
+#endif
+	}
+
+	return false;
+}
+
+
+} // end namespace mysqlpp
+

ADDED   lib/uds_connection.h
Index: lib/uds_connection.h
==================================================================
--- /dev/null
+++ lib/uds_connection.h
@@ -0,0 +1,105 @@
+/// \file uds_connection.h
+/// \brief Declares the UnixDomainSocketConnection class.
+
+/***********************************************************************
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_UDS_CONNECTION_H)
+#define MYSQLPP_UDS_CONNECTION_H
+
+#include "connection.h"
+
+namespace mysqlpp {
+
+/// \brief Specialization of \c Connection for Unix domain sockets
+///
+/// This class just simplifies the connection creation interface of
+/// \c Connection.  It does not add new functionality.
+
+class UnixDomainSocketConnection : public Connection
+{
+public:
+	/// \brief Create object without connecting it to the MySQL server.
+	UnixDomainSocketConnection() :
+	Connection()
+	{
+	}
+
+	/// \brief Create object and connect to database server over Unix
+	/// domain sockets in one step.
+	///
+	/// \param path filesystem path to socket
+	/// \param db name of database to use
+	/// \param user user name to log in under, or 0 to use the user
+	///		name the program is running under
+	/// \param password password to use when logging in
+	///
+	/// \b BEWARE: These parameters are not in the same order as those
+	/// in the corresponding constructor for Connection.  This is a
+	/// feature, not a bug. :)
+	UnixDomainSocketConnection(const char* path, const char* db = 0,
+			const char* user = 0, const char* password = 0) :
+	Connection()
+	{
+		connect(path, db, user, password);
+	}
+
+	/// \brief Establish a new connection using the same parameters as
+	/// an existing connection.
+	///
+	/// \param other pre-existing connection to clone
+	UnixDomainSocketConnection(const UnixDomainSocketConnection& other) :
+	Connection(other)
+	{
+	}
+
+	/// \brief Destroy object
+	~UnixDomainSocketConnection() { }
+
+	/// \brief Connect to database after object is created.
+	///
+	/// It's better to use the connect-on-create constructor if you can.
+	/// See its documentation for the meaning of these parameters.
+	///
+	/// If you call this method on an object that is already connected
+	/// to a database server, the previous connection is dropped and a
+	/// new connection is established.
+	bool connect(const char* path, const char* db = 0,
+			const char* user = 0, const char* password = 0);
+
+	/// \brief Check that the given path names a Unix domain socket and
+	/// that we have read-write permission for it
+	///
+	/// \param path the filesystem path to the socket
+	/// \param error on failure, reason is placed here; take default
+	/// if you do not need a reason if it fails
+	///
+	/// \return false if address fails to pass sanity checks
+	static bool is_socket(const char* path, std::string* error = 0);
+};
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_UDS_CONNECTION_H)
+

ADDED   lib/vallist.cpp
Index: lib/vallist.cpp
==================================================================
--- /dev/null
+++ lib/vallist.cpp
@@ -0,0 +1,144 @@
+/***********************************************************************
+ vallist.cpp - Implements utility functions for building value lists.
+	This is internal functionality used within the library.
+
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
+ MySQL AB, and (c) 2004-2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include "vallist.h"
+
+#include "result.h"
+#include "row.h"
+
+using std::string;
+
+namespace mysqlpp {
+
+void
+create_vector(size_t size, std::vector<bool>& v, bool t0, bool t1, bool t2,
+		bool t3, bool t4, bool t5, bool t6, bool t7, bool t8, bool t9,
+		bool ta, bool tb, bool tc)
+{
+	v.reserve(size);
+
+	v.push_back(t0);
+	if (size == 1) return;
+
+	v.push_back(t1);
+	if (size == 2) return;
+
+	v.push_back(t2);
+	if (size == 3) return;
+
+	v.push_back(t3);
+	if (size == 4) return;
+
+	v.push_back(t4);
+	if (size == 5) return;
+
+	v.push_back(t5);
+	if (size == 6) return;
+
+	v.push_back(t6);
+	if (size == 7) return;
+
+	v.push_back(t7);
+	if (size == 8) return;
+
+	v.push_back(t8);
+	if (size == 9) return;
+
+	v.push_back(t9);
+	if (size == 10) return;
+
+	v.push_back(ta);
+	if (size == 11) return;
+
+	v.push_back(tb);
+	if (size == 12) return;
+
+	v.push_back(tc);
+}
+
+
+template <class Container>
+void create_vector(const Container& c, std::vector<bool>& v,
+		std::string s0, std::string s1, std::string s2, std::string s3,
+		std::string s4, std::string s5, std::string s6, std::string s7,
+		std::string s8, std::string s9, std::string sa, std::string sb,
+		std::string sc)
+{
+	v.insert(v.begin(), c.size(), false);
+
+	v[c.field_num(s0.c_str())] = true;
+	if (s1.empty()) return;
+
+	v[c.field_num(s1.c_str())] = true;
+	if (s2.empty()) return;
+
+	v[c.field_num(s2.c_str())] = true;
+	if (s3.empty()) return;
+
+	v[c.field_num(s3.c_str())] = true;
+	if (s4.empty()) return;
+
+	v[c.field_num(s4.c_str())] = true;
+	if (s5.empty()) return;
+
+	v[c.field_num(s5.c_str())] = true;
+	if (s6.empty()) return;
+
+	v[c.field_num(s6.c_str())] = true;
+	if (s7.empty()) return;
+
+	v[c.field_num(s7.c_str())] = true;
+	if (s8.empty()) return;
+
+	v[c.field_num(s8.c_str())] = true;
+	if (s9.empty()) return;
+
+	v[c.field_num(s9.c_str())] = true;
+	if (sa.empty()) return;
+
+	v[c.field_num(sa.c_str())] = true;
+	if (sb.empty()) return;
+
+	v[c.field_num(sb.c_str())] = true;
+	if (sc.empty()) return;
+
+	v[c.field_num(sc.c_str())] = true;
+}
+
+
+#if !defined(DOXYGEN_IGNORE)
+// Instantiate above template.  Not sure why this is necessary.  Hide it
+// from Doxygen, because we clearly cannot appease it by documenting it.
+template void
+create_vector(const Row& c, std::vector<bool>& v, string s0,
+		string s1, string s2, string s3, string s4, string s5,
+		string s6, string s7, string s8, string s9, string sa,
+		string sb, string sc);
+#endif
+
+} // end namespace mysqlpp
+

ADDED   lib/vallist.h
Index: lib/vallist.h
==================================================================
--- /dev/null
+++ lib/vallist.h
@@ -0,0 +1,686 @@
+/// \file vallist.h
+/// \brief Declares templates for holding lists of values.
+
+/***********************************************************************
+ Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
+ MySQL AB, and (c) 2004, 2005 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the CREDITS
+ file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_VALLIST_H)
+#define MYSQLPP_VALLIST_H
+
+#include "manip.h"
+
+#include <string>
+#include <vector>
+
+namespace mysqlpp {
+
+
+/// \brief Holds two lists of items, typically used to construct a
+/// SQL "equals clause".
+///
+/// The WHERE clause in a SQL SELECT statment is an example of an
+/// equals clause.
+///
+/// Imagine an object of this type contains the lists (a, b) (c, d),
+/// and that the object's delimiter and equals symbols are set to ", "
+/// and " = " respectively.  When you insert that object into a C++
+/// stream, you would get "a = c, b = d".
+///
+/// This class is never instantiated by hand.  The equal_list()
+/// functions build instances of this structure template to do their
+/// work.  MySQL++'s SSQLS mechanism calls those functions when
+/// building SQL queries; you can call them yourself to do similar work.
+/// The "Harnessing SSQLS Internals" section of the user manual has
+/// some examples of this.
+///
+/// \sa equal_list_b
+
+template <class Seq1, class Seq2, class Manip>
+struct equal_list_ba
+{
+	/// \brief the list of objects on the left-hand side of the
+	/// equals sign
+	const Seq1* list1;
+
+	/// \brief the list of objects on the right-hand side of the
+	/// equals sign
+	const Seq2* list2;
+
+	/// \brief delimiter to use between each pair of elements
+	const char* delim;
+
+	/// \brief "equal" sign to use between each item in each equal
+	/// pair; doesn't have to actually be " = "
+	const char* equl;
+
+	/// \brief manipulator to use when inserting the equal_list into
+	/// a C++ stream
+	Manip manip;
+
+	/// \brief Create object
+	///
+	/// \param s1 list of objects on left-hand side of equal sign
+	/// \param s2 list of objects on right-hand side of equal sign
+	/// \param d what delimiter to use between each group in the list
+	///		when inserting the list into a C++ stream
+	/// \param e the "equals" sign between each pair of items in the
+	/// 	equal list; doesn't actually have to be " = "!
+	/// \param m manipulator to use when inserting the list into a
+	/// 	C++ stream
+	equal_list_ba(const Seq1& s1, const Seq2& s2, const char* d,
+			const char* e, Manip m) :
+	list1(&s1),
+	list2(&s2),
+	delim(d),
+	equl(e),
+	manip(m)
+	{
+	}
+};
+
+
+/// \brief Same as equal_list_ba, plus the option to have some elements
+/// of the equals clause suppressed.
+///
+/// Imagine an object of this type contains the lists (a, b, c)
+/// (d, e, f), that the object's 'fields' list is (true, false, true),
+/// and that the object's delimiter and equals symbols are set to
+/// " AND " and " = " respectively.  When you insert that object into a
+/// C++ stream, you would get "a = d AND c = f".
+///
+/// See equal_list_ba's documentation for more details.
+
+template <class Seq1, class Seq2, class Manip>
+struct equal_list_b
+{
+	/// \brief the list of objects on the left-hand side of the
+	/// equals sign
+	const Seq1* list1;
+
+	/// \brief the list of objects on the right-hand side of the
+	/// equals sign
+	const Seq2* list2;
+
+	/// \brief for each true item in the list, the pair in that position
+	/// will be inserted into a C++ stream
+	const std::vector<bool> fields;
+
+	/// \brief delimiter to use between each pair of elements
+	const char* delim;
+
+	/// \brief "equal" sign to use between each item in each equal
+	/// pair; doesn't have to actually be " = "
+	const char* equl;
+
+	/// \brief manipulator to use when inserting the equal_list into
+	/// a C++ stream
+	Manip manip;
+
+	/// \brief Create object
+	///
+	/// \param s1 list of objects on left-hand side of equal sign
+	/// \param s2 list of objects on right-hand side of equal sign
+	/// \param f for each true item in the list, the pair of items
+	///		in that position will be inserted into a C++ stream
+	/// \param d what delimiter to use between each group in the list
+	///		when inserting the list into a C++ stream
+	/// \param e the "equals" sign between each pair of items in the
+	/// 	equal list; doesn't actually have to be " = "!
+	/// \param m manipulator to use when inserting the list into a
+	/// 	C++ stream
+	equal_list_b(const Seq1& s1, const Seq2& s2,
+			const std::vector<bool>& f, const char* d,
+			const char* e, Manip m) :
+	list1(&s1),
+	list2(&s2),
+	fields(f),
+	delim(d),
+	equl(e),
+	manip(m)
+	{
+	}
+};
+
+
+/// \brief Holds a list of items, typically used to construct a SQL
+/// "value list".
+///
+/// The SQL INSERT statement has a VALUES clause; this class can
+/// be used to construct the list of items for that clause.
+///
+/// Imagine an object of this type contains the list (a, b, c), and
+/// that the object's delimiter symbol is set to ", ".  When you
+/// insert that object into a C++ stream, you would get "a, b, c".
+///
+/// This class is never instantiated by hand.  The value_list()
+/// functions build instances of this structure template to do their
+/// work.  MySQL++'s SSQLS mechanism calls those functions when
+/// building SQL queries; you can call them yourself to do similar work.
+/// The "Harnessing SSQLS Internals" section of the user manual has
+/// some examples of this.
+///
+/// \sa value_list_b
+
+template <class Seq, class Manip>
+struct value_list_ba
+{
+	/// \brief set of objects in the value list
+	const Seq* list;
+
+	/// \brief delimiter to use between each value in the list when
+	/// inserting it into a C++ stream
+	const char* delim;
+
+	/// \brief manipulator to use when inserting the list into a
+	/// C++ stream
+	Manip manip;
+
+	/// \brief Create object
+	///
+	/// \param s set of objects in the value list
+	/// \param d what delimiter to use between each value in the list
+	///		when inserting the list into a C++ stream
+	/// \param m manipulator to use when inserting the list into a
+	/// 	C++ stream
+	value_list_ba(const Seq& s, const char* d, Manip m) :
+	list(&s),
+	delim(d),
+	manip(m)
+	{
+	}
+};
+
+
+/// \brief Same as value_list_ba, plus the option to have some elements
+/// of the list suppressed.
+///
+/// Imagine an object of this type contains the list (a, b, c), that
+/// the object's 'fields' list is (true, false, true), and that the
+/// object's delimiter is set to ":".  When you insert that object
+/// into a C++ stream, you would get "a:c".
+///
+/// See value_list_ba's documentation for more details.
+
+template <class Seq, class Manip>
+struct value_list_b
+{
+	/// \brief set of objects in the value list
+	const Seq* list;
+
+	/// \brief delimiter to use between each value in the list when
+	/// inserting it into a C++ stream
+	const std::vector<bool> fields;
+
+	/// \brief delimiter to use between each value in the list when
+	/// inserting it into a C++ stream
+	const char* delim;
+
+	/// \brief manipulator to use when inserting the list into a C++
+	/// stream
+	Manip manip;
+
+	/// \brief Create object
+	///
+	/// \param s set of objects in the value list
+	/// \param f for each true item in the list, the list item
+	///		in that position will be inserted into a C++ stream
+	/// \param d what delimiter to use between each value in the list
+	///		when inserting the list into a C++ stream
+	/// \param m manipulator to use when inserting the list into a
+	/// 	C++ stream
+	value_list_b(const Seq& s, const std::vector<bool>& f,
+			const char* d, Manip m) :
+	list(&s),
+	fields(f),
+	delim(d),
+	manip(m)
+	{
+	}
+};
+
+
+/// \brief Inserts an equal_list_ba into an std::ostream.
+///
+/// Given two lists (a, b) and (c, d), a delimiter D, and an equals
+/// symbol E, this operator will insert "aEcDbEd" into the stream.
+///
+/// See equal_list_ba's documentation for concrete examples.
+///
+/// \sa equal_list()
+
+template <class Seq1, class Seq2, class Manip>
+std::ostream& operator <<(std::ostream& o,
+		const equal_list_ba<Seq1, Seq2, Manip>& el)
+{
+	typename Seq1::const_iterator i = el.list1->begin();
+	typename Seq2::const_iterator j = el.list2->begin();
+
+	while (1) {
+		o << *i << el.equl << el.manip << *j;
+		if ((++i == el.list1->end()) || (++j == el.list2->end())) {
+			break;
+		}
+		o << el.delim;
+	}
+
+	return o;
+}
+
+
+/// \brief Same as operator<< for equal_list_ba, plus the option to
+/// suppress insertion of some list items in the stream.
+///
+/// See equal_list_b's documentation for examples of how this works.
+
+template <class Seq1, class Seq2, class Manip>
+std::ostream& operator <<(std::ostream& o,
+		const equal_list_b <Seq1, Seq2, Manip>& el)
+{
+	typename Seq1::const_iterator i = el.list1->begin();
+	typename Seq2::const_iterator j = el.list2->begin();
+
+	int k = 0;
+	while (1) {
+		if (el.fields[k++]) {
+			o << *i << el.equl << el.manip << *j;
+		}
+		if ((++i == el.list1->end()) || (++j == el.list2->end())) {
+			break;
+		}
+		if (el.fields[k]) {
+			o << el.delim;
+		}
+	}
+
+	return o;
+}
+
+
+/// \brief Inserts a value_list_ba into an std::ostream.
+///
+/// Given a list (a, b) and a delimiter D, this operator will insert
+/// "aDb" into the stream.
+///
+/// See value_list_ba's documentation for concrete examples.
+///
+/// \sa value_list()
+
+template <class Seq, class Manip>
+std::ostream& operator <<(std::ostream& o,
+		const value_list_ba<Seq, Manip>& cl)
+{
+	typename Seq::const_iterator i = cl.list->begin();
+
+	while (1) {
+		o << cl.manip << *i;
+		if (++i == cl.list->end()) {
+			break;
+		}
+		o << cl.delim;
+	}
+
+	return o;
+}
+
+
+/// \brief Same as operator<< for value_list_ba, plus the option to
+/// suppress insertion of some list items in the stream.
+///
+/// See value_list_b's documentation for examples of how this works.
+
+template <class Seq, class Manip>
+std::ostream& operator <<(std::ostream& o,
+		const value_list_b<Seq, Manip>& cl)
+{
+	typename Seq::const_iterator i = cl.list->begin();
+
+	int k = 0;
+	while (1) {
+		if (cl.fields[k++]) {
+			o << cl.manip << *i;
+		}
+		if (++i == cl.list->end()) {
+			break; 
+		}
+		if (cl.fields[k]) {
+			o << cl.delim; 
+		}
+	}
+
+	return o;
+}
+
+
+/// \brief Create a vector of bool with the given arguments as values.
+///
+/// This function takes up to 13 bools, with the size parameter
+/// controlling the actual number of parameters we pay attention to.
+///
+/// This function is used within the library to build the vector used
+/// in calling the vector form of Row::equal_list(), Row::value_list(),
+/// and Row::field_list().  See the "Harnessing SSQLS Internals" section
+/// of the user manual to see that feature at work.
+
+void create_vector(size_t size, std::vector<bool>& v, bool t0,
+		bool t1 = false, bool t2 = false, bool t3 = false,
+		bool t4 = false, bool t5 = false, bool t6 = false,
+		bool t7 = false, bool t8 = false, bool t9 = false,
+		bool ta = false, bool tb = false, bool tc = false);
+
+
+/// \brief Create a vector of bool using a list of named fields.
+///
+/// This function is used with the ResUse and Result containers,
+/// which have a field_num() member function that maps a field name
+/// to its position number.  So for each named field, we set the
+/// bool in the vector at the corresponding position to true.
+///
+/// This function is used within the library to build the vector used
+/// in calling the vector form of Row::equal_list(), Row::value_list(),
+/// and Row::field_list().  See the "Harnessing SSQLS Internals" section
+/// of the user manual to see that feature at work.
+
+template <class Container>
+void create_vector(const Container& c, std::vector<bool>& v,
+		std::string s0, std::string s1, std::string s2,
+		std::string s3, std::string s4, std::string s5,
+		std::string s6, std::string s7, std::string s8,
+		std::string s9, std::string sa, std::string sb,
+		std::string sc);
+
+
+
+/// \brief Constructs a value_list_ba
+///
+/// This function returns a value list that uses the 'do_nothing'
+/// manipulator.  That is, the items are not quoted or escaped in any
+/// way.  See value_list(Seq, const char*, Manip) if you need to
+/// specify a manipulator.
+///
+/// \param s an STL sequence of items in the value list
+/// \param d delimiter operator<< should place between items
+
+template <class Seq>
+value_list_ba<Seq, do_nothing_type0>
+value_list(const Seq& s, const char* d = ",")
+{
+	return value_list_ba<Seq, do_nothing_type0>(s, d, do_nothing);
+}
+
+
+/// \brief Constructs a value_list_ba
+///
+/// \param s an STL sequence of items in the value list
+/// \param d delimiter operator<< should place between items
+/// \param m manipulator to use when inserting items into a stream
+
+template <class Seq, class Manip>
+value_list_ba<Seq, Manip>
+value_list(const Seq& s, const char* d, Manip m) 
+{
+	return value_list_ba<Seq, Manip>(s, d, m);
+}
+
+
+/// \brief Constructs a value_list_b (sparse value list)
+///
+/// \param s an STL sequence of items in the value list
+/// \param d delimiter operator<< should place between items
+/// \param m manipulator to use when inserting items into a stream
+/// \param vb for each item in this vector that is true, the
+/// corresponding item in the value list is inserted into a stream;
+/// the others are suppressed
+
+template <class Seq, class Manip>
+inline value_list_b<Seq, Manip>
+value_list(const Seq& s, const char* d, Manip m,
+		const std::vector<bool>& vb) 
+{
+	return value_list_b<Seq, Manip>(s, vb, d, m);
+}
+
+
+/// \brief Constructs a value_list_b (sparse value list)
+///
+/// Same as value_list(Seq&, const char*, Manip, const vector<bool>&),
+/// except that it takes the bools as arguments instead of wrapped up
+/// in a vector object.
+
+template <class Seq, class Manip>
+value_list_b<Seq, Manip>
+value_list(const Seq& s, const char* d, Manip m, bool t0,
+		bool t1 = false, bool t2 = false, bool t3 = false,
+		bool t4 = false, bool t5 = false, bool t6 = false,
+		bool t7 = false, bool t8 = false, bool t9 = false,
+		bool ta = false, bool tb = false, bool tc = false)
+{
+	std::vector<bool> vb;
+	create_vector(s.size(), vb, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9,
+				  ta, tb, tc);
+	return value_list_b<Seq, Manip>(s, vb, d, m);
+}
+
+/// \brief Constructs a sparse value list
+///
+/// Same as value_list(Seq&, const char*, Manip, bool, bool...) but
+/// without the Manip parameter.  We use the do_nothing manipulator,
+/// meaning that the value list items are neither escaped nor quoted
+/// when being inserted into a stream.
+
+template <class Seq>
+value_list_b<Seq, do_nothing_type0>
+value_list(const Seq& s, const char* d, bool t0,
+		bool t1 = false, bool t2 = false, bool t3 = false,
+		bool t4 = false, bool t5 = false, bool t6 = false,
+		bool t7 = false, bool t8 = false, bool t9 = false,
+		bool ta = false, bool tb = false, bool tc = false)
+{
+	std::vector<bool> vb;
+	create_vector(s.size(), vb, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9,
+				  ta, tb, tc);
+	return value_list_b<Seq, do_nothing_type0>(s, vb, d, do_nothing);
+}
+
+
+/// \brief Constructs a sparse value list
+///
+/// Same as value_list(Seq&, const char*, Manip, bool, bool...) but
+/// without the Manip or delimiter parameters.  We use the do_nothing
+/// manipulator, meaning that the value list items are neither escaped
+/// nor quoted when being inserted into a stream.  The delimiter is a
+/// comma.  This form is suitable for lists of simple data, such as
+/// integers.
+
+template <class Seq>
+value_list_b<Seq, do_nothing_type0>
+value_list(const Seq& s, bool t0,
+		bool t1 = false, bool t2 = false, bool t3 = false,
+		bool t4 = false, bool t5 = false, bool t6 = false,
+		bool t7 = false, bool t8 = false, bool t9 = false,
+		bool ta = false, bool tb = false, bool tc = false)
+{
+	std::vector<bool> vb;
+	create_vector(s.size(), vb, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9,
+				  ta, tb, tc);
+	return value_list_b<Seq, do_nothing_type0>(s, vb, ",", do_nothing);
+}
+
+
+/// \brief Constructs an equal_list_ba
+///
+/// This function returns an equal list that uses the 'do_nothing'
+/// manipulator.  That is, the items are not quoted or escaped in any
+/// way when inserted into a stream.  See equal_list(Seq, Seq,
+/// const char*, const char*, Manip) if you need a different
+/// manipulator.
+///
+/// The idea is for both lists to be of equal length because
+/// corresponding elements from each list are handled as pairs, but if
+/// one list is shorter than the other, the generated list will have
+/// that many elements.
+///
+/// \param s1 items on the left side of the equals sign when the
+/// equal list is inserted into a stream
+/// \param s2 items on the right side of the equals sign
+/// \param d delimiter operator<< should place between pairs
+/// \param e what operator<< should place between items in each pair;
+/// by default, an equals sign, as that is the primary use for this
+/// mechanism.
+
+template <class Seq1, class Seq2>
+equal_list_ba<Seq1, Seq2, do_nothing_type0>
+equal_list(const Seq1& s1, const Seq2& s2, const char *d = ",",
+		const char *e = " = ")
+{
+	return equal_list_ba<Seq1, Seq2, do_nothing_type0>(s1, s2, d,
+			e, do_nothing);
+}
+
+
+/// \brief Constructs an equal_list_ba
+///
+/// Same as equal_list(Seq&, Seq&, const char*, const char*) except that
+/// it also lets you specify the manipulator.  Use this version if the
+/// data must be escaped or quoted when being inserted into a stream.
+
+template <class Seq1, class Seq2, class Manip>
+equal_list_ba<Seq1, Seq2, Manip>
+equal_list(const Seq1& s1, const Seq2& s2, const char* d,
+		const char* e, Manip m)
+{
+	return equal_list_ba<Seq1, Seq2, Manip>(s1, s2, d, e, m);
+}
+
+
+/// \brief Constructs a equal_list_b (sparse equal list)
+///
+/// Same as equal_list(Seq&, Seq&, const char*, const char*, Manip) except
+/// that you can pass a vector of bools. For each true item in that
+/// list, operator<< adds the corresponding item is put in the equal
+/// list.  This lets you pass in sequences when you don't want all of
+/// the elements to be inserted into a stream.
+
+template <class Seq1, class Seq2, class Manip>
+equal_list_b<Seq1, Seq2, Manip>
+equal_list(const Seq1& s1, const Seq2& s2, const char* d,
+		const char *e, Manip m, const std::vector<bool>& vb)
+{
+	return equal_list_b<Seq1, Seq2, Manip>(s1, s2, vb, d, e, m);
+}
+
+
+/// \brief Constructs a equal_list_b (sparse equal list)
+///
+/// Same as equal_list(Seq&, Seq&, const char*, const char*, Manip,
+/// vector<bool>&) except that it takes boolean parameters
+/// instead of a list of bools.
+
+template <class Seq1, class Seq2, class Manip>
+equal_list_b<Seq1, Seq2, Manip>
+equal_list(const Seq1& s1, const Seq2& s2, const char* d,
+		const char* e, Manip m, bool t0, bool t1 = false,
+		bool t2 = false, bool t3 = false, bool t4 = false,
+		bool t5 = false, bool t6 = false, bool t7 = false,
+		bool t8 = false, bool t9 = false, bool ta = false,
+		bool tb = false, bool tc = false)
+{
+	std::vector<bool> vb;
+	create_vector(s1.size(), vb, t0, t1, t2, t3, t4, t5, t6, t7, t8,
+				  t9, ta, tb, tc);
+	return equal_list_b<Seq1, Seq2, Manip>(s1, s2, vb, d, e, m);
+}
+
+
+/// \brief Constructs a equal_list_b (sparse equal list)
+///
+/// Same as equal_list(Seq&, Seq&, const char*, const char*, Manip,
+/// bool, bool...) except that it doesn't take the Manip argument.
+/// It uses the do_nothing manipulator instead, meaning that none of
+/// the elements are escaped when being inserted into a stream.
+
+template <class Seq1, class Seq2>
+equal_list_b<Seq1, Seq2, do_nothing_type0>
+equal_list(const Seq1& s1, const Seq2& s2, const char* d,
+		const char* e, bool t0, bool t1 = false, bool t2 = false,
+		bool t3 = false, bool t4 = false, bool t5 = false,
+		bool t6 = false, bool t7 = false, bool t8 = false,
+		bool t9 = false, bool ta = false, bool tb = false,
+		bool tc = false)
+{
+	std::vector<bool> vb;
+	create_vector(s1.size(), vb, t0, t1, t2, t3, t4, t5, t6, t7, t8,
+				  t9, ta, tb, tc);
+	return equal_list_b<Seq1, Seq2, do_nothing_type0>(s1, s2, vb,
+			d, e, do_nothing);
+}
+
+
+/// \brief Constructs a equal_list_b (sparse equal list)
+///
+/// Same as equal_list(Seq&, Seq&, const char*, const char*, bool,
+/// bool...) except that it doesn't take the second const char*
+/// argument.  It uses " = " for the equals symbol.
+
+template <class Seq1, class Seq2>
+equal_list_b<Seq1, Seq2, do_nothing_type0>
+equal_list(const Seq1& s1, const Seq2& s2, const char* d, bool t0,
+		bool t1 = false, bool t2 = false, bool t3 = false,
+		bool t4 = false, bool t5 = false, bool t6 = false,
+		bool t7 = false, bool t8 = false, bool t9 = false,
+		bool ta = false, bool tb = false, bool tc = false)
+{
+	std::vector<bool> vb;
+	create_vector(s1.size(), vb, t0, t1, t2, t3, t4, t5, t6, t7, t8,
+				  t9, ta, tb, tc);
+	return equal_list_b<Seq1, Seq2, do_nothing_type0>(s1, s2, vb,
+			d, " = ", do_nothing);
+}
+
+
+/// \brief Constructs a equal_list_b (sparse equal list)
+///
+/// Same as equal_list(Seq&, Seq&, const char*, bool, bool...) except
+/// that it doesn't take the const char* argument.  It uses a comma for
+/// the delimiter.  This form is useful for building simple equals
+/// lists, where no manipulators are necessary, and the default
+/// delimiter and equals symbol are suitable.
+
+template <class Seq1, class Seq2>
+equal_list_b<Seq1, Seq2, do_nothing_type0>
+equal_list(const Seq1& s1, const Seq2& s2, bool t0, bool t1 = false,
+		bool t2 = false, bool t3 = false, bool t4 = false,
+		bool t5 = false, bool t6 = false, bool t7 = false,
+		bool t8 = false, bool t9 = false, bool ta = false,
+		bool tb = false, bool tc = false)
+{
+	std::vector<bool> vb;
+	create_vector(s1.size(), vb, t0, t1, t2, t3, t4, t5, t6, t7, t8,
+				  t9, ta, tb, tc);
+	return equal_list_b<Seq1, Seq2, do_nothing_type0>(s1, s2, vb,
+			",", " = ", do_nothing);
+}
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_VALLIST_H)

ADDED   lib/wnp_connection.cpp
Index: lib/wnp_connection.cpp
==================================================================
--- /dev/null
+++ lib/wnp_connection.cpp
@@ -0,0 +1,73 @@
+/***********************************************************************
+ wnp_connection.cpp - Implements the WindowsNamedPipeConnection class.
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#define MYSQLPP_NOT_HEADER
+#include "common.h"
+#include "wnp_connection.h"
+
+#include "exceptions.h"
+
+using namespace std;
+
+namespace mysqlpp {
+
+static const char* common_complaint =
+		"WindowsNamedPipeConnection only works on Windows";
+
+
+bool
+WindowsNamedPipeConnection::connect(const char* db, const char* user,
+		const char* pass)
+{
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+	return Connection::connect(db, ".", user, pass);
+#else
+	(void)db;
+	(void)user;
+	(void)pass;
+	error_message_ = common_complaint;
+	if (throw_exceptions()) {
+		throw ConnectionFailed(error_message_.c_str());
+	}
+	else {
+		return false;
+	}
+#endif
+}
+
+
+bool
+WindowsNamedPipeConnection::is_wnp(const char* server)
+{
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+	return server && (strcmp(server, ".") == 0);
+#else
+	(void)server;
+	return false;
+#endif
+}
+
+} // end namespace mysqlpp
+

ADDED   lib/wnp_connection.h
Index: lib/wnp_connection.h
==================================================================
--- /dev/null
+++ lib/wnp_connection.h
@@ -0,0 +1,99 @@
+/// \file wnp_connection.h
+/// \brief Declares the WindowsNamedPipeConnection class.
+
+/***********************************************************************
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#if !defined(MYSQLPP_WNP_CONNECTION_H)
+#define MYSQLPP_WNP_CONNECTION_H
+
+#include "connection.h"
+
+namespace mysqlpp {
+
+/// \brief Specialization of \c Connection for Windows named pipes
+///
+/// This class just simplifies the connection creation interface of
+/// \c Connection.  It does not add new functionality.
+
+class MYSQLPP_EXPORT WindowsNamedPipeConnection : public Connection
+{
+public:
+	/// \brief Create object without connecting it to the MySQL server.
+	WindowsNamedPipeConnection() :
+	Connection()
+	{
+	}
+
+	/// \brief Create object and connect to database server over Windows
+	/// named pipes in one step.
+	///
+	/// \param db name of database to use
+	/// \param user user name to log in under, or 0 to use the user
+	///		name the program is running under
+	/// \param password password to use when logging in
+	WindowsNamedPipeConnection(const char* db, const char* user = 0,
+			const char* password = 0) :
+	Connection()
+	{
+		connect(db, user, password);
+	}
+
+	/// \brief Establish a new connection using the same parameters as
+	/// an existing connection.
+	///
+	/// \param other pre-existing connection to clone
+	WindowsNamedPipeConnection(const WindowsNamedPipeConnection& other) :
+	Connection(other)
+	{
+	}
+
+	/// \brief Destroy object
+	~WindowsNamedPipeConnection() { }
+
+	/// \brief Connect to database after object is created.
+	///
+	/// It's better to use the connect-on-create constructor if you can.
+	/// See its documentation for the meaning of these parameters.
+	///
+	/// If you call this method on an object that is already connected
+	/// to a database server, the previous connection is dropped and a
+	/// new connection is established.
+	bool connect(const char* db = 0, const char* user = 0,
+			const char* password = 0);
+
+	/// \brief Check that given string denotes a Windows named pipe
+	/// connection to MySQL
+	///
+	/// \param server the server address
+	///
+	/// \return false if server address does not denote a Windows
+	/// named pipe connection, or we are not running on Windows
+	static bool is_wnp(const char* server);
+};
+
+
+} // end namespace mysqlpp
+
+#endif // !defined(MYSQLPP_WNP_CONNECTION_H)
+

ADDED   libmysqlclient.def
Index: libmysqlclient.def
==================================================================
--- /dev/null
+++ libmysqlclient.def
@@ -0,0 +1,148 @@
+LIBRARY LIBMYSQL.dll
+EXPORTS
+_dig_vec_lower DATA
+_dig_vec_upper DATA
+bmove_upp
+client_errors DATA
+delete_dynamic
+free_defaults
+get_defaults_files
+getopt_compare_strings
+getopt_ull_limit_value
+handle_options
+init_dynamic_array
+insert_dynamic
+int2str
+is_prefix
+list_add
+list_delete
+load_defaults
+my_end
+my_getopt_print_errors DATA
+my_init
+my_malloc
+my_memdup
+my_no_flags_free
+my_path
+my_print_help
+my_print_variables
+my_realloc
+my_strdup
+myodbc_remove_escape
+mysql_affected_rows@4
+mysql_autocommit
+mysql_change_user
+mysql_character_set_name
+mysql_close@4
+mysql_commit
+mysql_data_seek@12
+mysql_debug
+mysql_disable_reads_from_master
+mysql_disable_rpl_parse
+mysql_dump_debug_info
+mysql_embedded
+mysql_enable_reads_from_master
+mysql_enable_rpl_parse
+mysql_eof
+mysql_errno@4
+mysql_error@4
+mysql_escape_string@12
+mysql_fetch_field@4
+mysql_fetch_field_direct@8
+mysql_fetch_fields
+mysql_fetch_lengths@4
+mysql_fetch_row@4
+mysql_field_count@4
+mysql_field_seek@8
+mysql_field_tell
+mysql_free_result@4
+mysql_get_client_info@0
+mysql_get_client_version
+mysql_get_host_info@4
+mysql_get_parameters
+mysql_get_proto_info@4
+mysql_get_server_info@4
+mysql_get_server_version
+mysql_hex_string
+mysql_info@4
+mysql_init@4
+mysql_insert_id@4
+mysql_kill@8
+mysql_list_dbs
+mysql_list_fields
+mysql_list_processes
+mysql_list_tables
+mysql_master_query
+mysql_more_results@4
+mysql_next_result@4
+mysql_num_fields@4
+mysql_num_rows@4
+mysql_odbc_escape_string
+mysql_options@12
+mysql_ping@4
+mysql_query@8
+mysql_read_query_result
+mysql_real_connect@32
+mysql_real_escape_string@16
+mysql_real_query@12
+mysql_refresh@8
+mysql_rollback
+mysql_row_seek
+mysql_row_tell
+mysql_rpl_parse_enabled
+mysql_rpl_probe
+mysql_rpl_query_type
+mysql_select_db@8
+mysql_send_query
+mysql_set_character_set
+mysql_set_local_infile_default
+mysql_set_local_infile_handler
+mysql_set_server_option@8
+mysql_shutdown@8
+mysql_slave_query
+mysql_sqlstate
+mysql_ssl_set@24
+mysql_stat@4
+mysql_stmt_affected_rows
+mysql_stmt_attr_get
+mysql_stmt_attr_set
+mysql_stmt_bind_param
+mysql_stmt_bind_result
+mysql_stmt_close
+mysql_stmt_data_seek
+mysql_stmt_errno
+mysql_stmt_error
+mysql_stmt_execute
+mysql_stmt_fetch
+mysql_stmt_fetch_column
+mysql_stmt_field_count
+mysql_stmt_free_result
+mysql_stmt_init
+mysql_stmt_insert_id
+mysql_stmt_num_rows
+mysql_stmt_param_count
+mysql_stmt_param_metadata
+mysql_stmt_prepare
+mysql_stmt_reset
+mysql_stmt_result_metadata
+mysql_stmt_row_seek
+mysql_stmt_row_tell
+mysql_stmt_send_long_data
+mysql_stmt_sqlstate
+mysql_stmt_store_result
+mysql_store_result@4
+mysql_thread_end@0
+mysql_thread_id@4
+mysql_thread_init@0
+mysql_thread_safe@0
+mysql_use_result@4
+mysql_warning_count
+set_dynamic
+strcend
+strcont
+strdup_root
+strfill
+strinstr
+strmake
+strmov
+strxmov

ADDED   mysql++.bkl
Index: mysql++.bkl
==================================================================
--- /dev/null
+++ mysql++.bkl
@@ -0,0 +1,527 @@
+<?xml version="1.0"?>
+<makefile>
+    <requires version="0.2.3"/>
+    <using module="datafiles"/>
+    <include file="presets/simple.bkl"/>
+
+    <set var="DDD">$(DOLLAR)$(DOLLAR)d</set>
+    <set var="DDF">$(DOLLAR)$(DOLLAR)f</set>
+    <set var="ZLIB">yes</set>
+
+    <set var="PLATFORM_WINDOWS_NATIVE">no</set>
+    <set var="THREAD_TYPE">single</set>
+    <if cond="FORMAT in ['msvs2003prj', 'msvs2005prj', 'mingw']">
+        <set var="PLATFORM_WINDOWS_NATIVE">yes</set>
+        <set var="THREAD_TYPE">multi</set>
+    </if>
+        
+    <option name="BUILD">
+        <values>debug,release</values>
+        <values-description>Debug,Release</values-description>
+        <default-value>debug</default-value>
+        <description>
+            Type of compiled binaries
+        </description>
+    </option>
+
+    <set var="MYSQL_WIN_DIR">
+        C:\Program Files\MySQL\MySQL Server 5.0
+    </set>
+
+    <set var="DEBUGINFO">
+        <if cond="BUILD=='debug'">on</if>
+        <if cond="BUILD=='release'">off</if>
+    </set>
+
+    <!-- This convoluted syntax adds "_d" to the end of library and DLL
+         file names for VC++ and Xcode, in debug mode only. -->
+    <set var="DEBUG_SUFFIX"/>
+    <set var="DEBUG_SUFFIX">
+        <if cond="FORMAT in ['msvs2003prj', 'msvs2005prj', 'xcode2'] and BUILD=='debug'">_d</if>
+    </set>
+
+    <set var="BUILDDOCS">yes</set>
+    <set var="BUILDEXAMPLES">yes</set>
+    <set var="BUILDLIBRARY">yes</set>
+    <set var="BUILDTEST">yes</set>
+    <set var="HEADER_DIR">$(PREFIX)/include/mysql++</set>
+
+	<if cond="FORMAT in ['msvs2003prj', 'msvs2005prj']">
+		<set-srcdir>..</set-srcdir>
+    </if>
+
+    <if cond="BUILDLIBRARY=='yes'">
+        <dll id="mysqlpp">
+            <dllname>mysqlpp$(DEBUG_SUFFIX)</dllname>
+            <libname>mysqlpp$(DEBUG_SUFFIX)</libname>
+            <so_version>3.0.3</so_version>
+
+            <sources>
+                lib/beemutex.cpp
+                lib/connection.cpp
+                lib/cpool.cpp
+                lib/datetime.cpp
+                lib/dbdriver.cpp
+                lib/field_names.cpp
+                lib/field_types.cpp
+                lib/manip.cpp
+                lib/myset.cpp
+                lib/mysql++.cpp
+                lib/mystring.cpp
+                lib/null.cpp
+                lib/options.cpp
+                lib/qparms.cpp
+                lib/query.cpp
+                lib/result.cpp
+                lib/row.cpp
+                lib/sql_buffer.cpp
+                lib/stadapter.cpp
+                lib/tcp_connection.cpp
+                lib/transaction.cpp
+                lib/type_info.cpp
+                lib/uds_connection.cpp
+                lib/vallist.cpp
+                lib/wnp_connection.cpp
+            </sources>
+
+            <debug-info>$(DEBUGINFO)</debug-info>
+
+            <threading>$(THREAD_TYPE)</threading>
+            <cxx-rtti>on</cxx-rtti>
+            <cxx-exceptions>on</cxx-exceptions>
+            
+            <install-to>$(LIBDIR)</install-to>
+            
+            <if cond="PLATFORM_WINDOWS_NATIVE=='yes'">
+                <define>UNICODE</define>
+                <define>_UNICODE</define>
+                <sys-lib>wsock32</sys-lib>
+            </if>
+
+			<if cond="FORMAT in ['msvs2003prj', 'msvs2005prj']">
+                <define>MYSQLPP_MAKING_DLL</define>
+                <define>HAVE_MYSQL_SSL_SET</define>
+                <include>$(MYSQL_WIN_DIR)\include</include>
+                <lib-path>$(MYSQL_WIN_DIR)\lib\opt</lib-path>
+                <sys-lib>libmysql</sys-lib>
+            </if>
+
+            <if cond="FORMAT=='mingw'">
+                <define>MYSQLPP_NO_DLL</define>
+                <define>HAVE_MYSQL_SSL_SET</define>
+                <include>"$(MYSQL_WIN_DIR)\include"</include>
+                <lib-path>"$(MYSQL_WIN_DIR)\lib\opt"</lib-path>
+                <sys-lib>mysqlclient</sys-lib>
+            </if>
+
+            <if cond="FORMAT=='autoconf'">
+                <depends>lib/ssqls.h</depends>
+                <depends>lib/querydef.h</depends>
+
+                <cxxflags>@PTHREAD_CFLAGS@</cxxflags>
+                <include>.</include>
+                <ldflags>@PTHREAD_LIBS@ @MYSQLPP_EXTRA_LIBS@</ldflags>
+                <sys-lib>@MYSQL_C_LIB@</sys-lib>
+
+                <if cond="ZLIB=='yes'">
+                    <sys-lib>z</sys-lib>
+                </if>
+
+                <modify-target target="uninstall">
+                    <command>
+                        rm -f $(DESTDIR)$(libdir)/$(DLLPREFIX)mysqlpp.$(SO_SUFFIX)
+                    </command>
+                    <command>
+                        for f in *.h ; do rm -f $(HEADER_DIR)/$(DDF) ; done
+                    </command>
+                    <command>rmdir $(HEADER_DIR)</command>
+                </modify-target>
+            </if>
+        </dll>
+
+        <data-files>
+            <files>lib/*.h</files>
+            <install-to>$(HEADER_DIR)</install-to>
+        </data-files>
+    </if>   <!-- build library -->
+
+    <!-- Set up build options common to all built executables -->
+    <template id="programs">
+        <if cond="BUILDLIBRARY=='yes'">
+            <depends>mysqlpp</depends>
+        </if>
+    
+        <threading>$(THREAD_TYPE)</threading>
+        <cxx-rtti>on</cxx-rtti>
+        <cxx-exceptions>on</cxx-exceptions>
+        <debug-info>$(DEBUGINFO)</debug-info>
+
+        <if cond="FORMAT in ['autoconf', 'gnu', 'mingw', 'xcode2']">
+			<include>lib</include>
+            <lib-path>.</lib-path>
+        </if>
+		<if cond="FORMAT in ['msvs2003prj', 'msvs2005prj']">
+			<include>../lib</include>
+		</if>
+
+        <if cond="PLATFORM_WINDOWS_NATIVE=='yes'">
+            <define>UNICODE</define>
+            <define>_UNICODE</define>
+        </if>
+
+        <if cond="FORMAT=='autoconf'">
+            <cxxflags>@PTHREAD_CFLAGS@</cxxflags>
+            <ldflags>@PTHREAD_LIBS@ @MYSQLPP_EXTRA_LIBS@</ldflags>
+            <sys-lib>@MYSQL_C_LIB@</sys-lib>
+            <warnings>max</warnings>
+            <sys-lib>mysqlpp</sys-lib>
+            <if cond="ZLIB=='yes'">
+                <sys-lib>z</sys-lib>
+            </if>
+        </if>
+
+        <if cond="FORMAT=='mingw'">
+            <define>MYSQLPP_NO_DLL</define>
+            <ldflags>
+                -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc
+            </ldflags>
+            <include>"$(MYSQL_WIN_DIR)\include"</include>
+            <lib-path>"$(MYSQL_WIN_DIR)\lib\opt"</lib-path>
+            <sys-lib>mysqlclient</sys-lib>
+            <sys-lib>mysqlpp$(DEBUG_SUFFIX)</sys-lib>
+        </if>
+
+		<if cond="FORMAT in ['msvs2003prj', 'msvs2005prj']">
+            <lib-path>$(BUILD)</lib-path>
+            <include>$(MYSQL_WIN_DIR)\include</include>
+            <lib-path>$(MYSQL_WIN_DIR)\lib\opt</lib-path>
+            <sys-lib>mysqlpp$(DEBUG_SUFFIX)</sys-lib>
+            <sys-lib>libmysql</sys-lib>
+        </if>
+
+        <if cond="FORMAT=='gnu'">
+            <include>/usr/include/mysql</include>
+            <include>/usr/include/mysql++</include>
+            <sys-lib>mysqlpp</sys-lib>
+            <sys-lib>mysqlclient</sys-lib>
+        </if>
+
+        <if cond="FORMAT=='xcode2'">
+            <include>/usr/local/mysql/include</include>
+            <sys-lib>mysqlclient</sys-lib>
+            <sys-lib>mysqlpp$(DEBUG_SUFFIX)</sys-lib>
+        </if>
+    </template>
+
+    <!-- Define library testing programs' output targets, if enabled -->
+    <if cond="BUILDTEST=='yes'">
+        <exe id="test_cpool" template="programs">
+            <sources>test/cpool.cpp</sources>
+        </exe>
+        <exe id="test_datetime" template="programs">
+            <sources>test/datetime.cpp</sources>
+        </exe>
+        <exe id="test_inttypes" template="programs">
+            <sources>test/inttypes.cpp</sources>
+        </exe>
+        <exe id="test_manip" template="programs">
+            <sources>test/manip.cpp</sources>
+        </exe>
+        <if cond="FORMAT!='msvs2003prj'">
+            <!-- VC++ 2003 can't compile this -->
+			<exe id="test_null_comparison" template="programs">
+				<sources>test/null_comparison.cpp</sources>
+			</exe>
+		</if>
+        <if cond="FORMAT!='msvs2003prj'">
+            <!-- VC++ 2003 can't compile this -->
+			<exe id="test_qssqls" template="programs">
+				<sources>test/qssqls.cpp</sources>
+			</exe>
+		</if>
+        <exe id="test_qstream" template="programs">
+            <sources>test/qstream.cpp</sources>
+        </exe>
+        <if cond="FORMAT!='msvs2003prj'">
+            <!-- VC++ 2003 can't compile this -->
+            <exe id="test_string" template="programs">
+                <sources>test/string.cpp</sources>
+            </exe>
+        </if>
+        <exe id="test_tcp" template="programs">
+            <sources>test/tcp.cpp</sources>
+        </exe>
+        <exe id="test_uds" template="programs">
+            <sources>test/uds.cpp</sources>
+        </exe>
+        <exe id="test_wnp" template="programs">
+            <sources>test/wnp.cpp</sources>
+        </exe>
+    </if>   <!-- build library test programs -->
+
+    <!-- Define example programs' output targets, if enabled -->
+    <if cond="BUILDEXAMPLES=='yes'">
+        <!-- Options specific to examples that depend on libexcommon -->
+        <template id="libexcommon-user">
+            <depends>excommon</depends>
+            <sys-lib>mysqlpp_excommon</sys-lib>
+        </template>
+
+        <!-- Convenience library of routines used by most examples -->
+        <lib id="excommon" template="programs">
+            <libname>mysqlpp_excommon</libname>
+            <sources>examples/cmdline.cpp</sources>
+            <sources>examples/printdata.cpp</sources>
+        </lib>
+
+        <!-- The examples themselves -->
+        <if cond="FORMAT!='msvs2003prj'">
+            <!-- VC++ 2003 can't compile current SSQLS code -->
+			<exe id="cgi_jpeg" template="libexcommon-user,programs">
+				<sources>examples/cgi_jpeg.cpp</sources>
+			</exe>
+        </if>
+        <exe id="cpool" template="libexcommon-user,programs">
+            <sources>examples/cpool.cpp</sources>
+        </exe>
+        <exe id="dbinfo" template="libexcommon-user,programs">
+            <sources>examples/dbinfo.cpp</sources>
+        </exe>
+        <exe id="deadlock" template="libexcommon-user,programs">
+            <sources>examples/deadlock.cpp</sources>
+        </exe>
+        <exe id="fieldinf" template="libexcommon-user,programs">
+            <sources>examples/fieldinf.cpp</sources>
+        </exe>
+        <if cond="FORMAT!='msvs2003prj'">
+            <!-- VC++ 2003 can't compile current SSQLS code -->
+			<exe id="for_each" template="libexcommon-user,programs">
+				<sources>examples/for_each.cpp</sources>
+			</exe>
+        </if>
+        <exe id="load_jpeg" template="libexcommon-user,programs">
+            <sources>examples/load_jpeg.cpp</sources>
+        </exe>
+        <exe id="multiquery" template="libexcommon-user,programs">
+            <sources>examples/multiquery.cpp</sources>
+        </exe>
+        <exe id="resetdb" template="libexcommon-user,programs">
+            <sources>examples/resetdb.cpp</sources>
+        </exe>
+        <exe id="simple1" template="libexcommon-user,programs">
+            <sources>examples/simple1.cpp</sources>
+        </exe>
+        <exe id="simple2" template="libexcommon-user,programs">
+            <sources>examples/simple2.cpp</sources>
+        </exe>
+        <exe id="simple3" template="libexcommon-user,programs">
+            <sources>examples/simple3.cpp</sources>
+        </exe>
+        <if cond="FORMAT!='msvs2003prj'">
+            <!-- VC++ 2003 can't compile current SSQLS code -->
+			<exe id="ssqls1" template="libexcommon-user,programs">
+				<sources>examples/ssqls1.cpp</sources>
+			</exe>
+			<exe id="ssqls2" template="libexcommon-user,programs">
+				<sources>examples/ssqls2.cpp</sources>
+			</exe>
+			<exe id="ssqls3" template="libexcommon-user,programs">
+				<sources>examples/ssqls3.cpp</sources>
+			</exe>
+			<exe id="ssqls4" template="libexcommon-user,programs">
+				<sources>examples/ssqls4.cpp</sources>
+			</exe>
+			<exe id="ssqls5" template="libexcommon-user,programs">
+				<sources>examples/ssqls5.cpp</sources>
+			</exe>
+			<exe id="store_if" template="libexcommon-user,programs">
+				<sources>examples/store_if.cpp</sources>
+			</exe>
+        </if>
+        <exe id="tquery1" template="libexcommon-user,programs">
+            <sources>examples/tquery1.cpp</sources>
+        </exe>
+        <exe id="tquery2" template="libexcommon-user,programs">
+            <sources>examples/tquery2.cpp</sources>
+        </exe>
+        <exe id="tquery3" template="libexcommon-user,programs">
+            <sources>examples/tquery3.cpp</sources>
+        </exe>
+        <if cond="FORMAT!='msvs2003prj'">
+            <!-- VC++ 2003 can't compile current SSQLS code -->
+			<exe id="transaction" template="libexcommon-user,programs">
+				<sources>examples/transaction.cpp</sources>
+			</exe>
+        </if>
+    </if>   <!-- build examples -->
+
+    <if cond="FORMAT=='autoconf'">
+        <set var="PKGNAME">@PACKAGE_NAME@-@PACKAGE_VERSION@</set>
+
+        <modify-target target="clean">
+            <command>
+                rm -rf doc/latex doc/pdf ; \
+                cd doc/html/refman ; \
+                rm -f doxygen.css [a-z]*.{dot,html,map,md5,png}
+            </command>
+        </modify-target>
+            
+        <action id="lib/ssqls.h">
+            <command>cd lib ; ./ssqls.pl</command>
+            <depends-on-file>lib/ssqls.pl</depends-on-file>
+        </action>
+
+        <action id="lib/querydef.h">
+            <command>cd lib ; ./querydef.pl</command>
+            <depends-on-file>lib/querydef.pl</depends-on-file>
+        </action>
+
+        <action id="tags">
+            <is-phony/>
+            <command>ctags `pwd`/{examples,lib}/*.{cpp,h}</command>
+            <command>for d in examples lib ; do cd $(DDD) ; ln -sf ../tags . ; cd .. ; done</command>
+        </action>
+        <action id="ctags"><depends>tags</depends></action>
+
+        <action id="doc/html/refman/index.html">
+            <depends-on-file>lib/Doxyfile</depends-on-file>
+            <depends-on-file>lib/*.cpp</depends-on-file>
+            <depends-on-file>lib/*.h</depends-on-file>
+            <command>
+                mkdir -p doc/latex ; cd lib ; doxygen > /dev/null
+            </command>
+            <command>
+                mkdir -p doc/pdf ; cd doc/latex ; make ; cp refman.pdf ../pdf
+            </command>
+        </action>
+
+        <action id="doc/html/userman/index.html">
+            <depends-on-file>doc/userman/*.dbx</depends-on-file>
+            <depends-on-file>doc/userman/userman.dbx.in</depends-on-file>
+            <command>
+                cd doc/userman ; make html pdf ; cp userman.pdf ../pdf
+            </command>
+        </action>
+
+        <action id="doc">
+            <depends>doc/html/refman/index.html</depends>
+            <depends>doc/html/userman/index.html</depends>
+        </action>
+
+        <action id="@PACKAGE_NAME@-@PACKAGE_VERSION@">
+            <!-- Set up package directory -->
+            <command>
+                for d in config doc/{.,html}/{refman,userman} examples lib test ; \
+                do \
+                    mkdir -p $(PKGNAME)/$(DDD) ; \
+                done
+            </command>
+
+            <!-- Copy files into package directory -->
+            <!-- top directory -->
+            <command>
+                cp -RL *.bat *.txt Bakefiles.bkgen bootstrap ChangeLog \
+					cleanmf config.guess config.h.in config.sub configure* \
+                    dtest exrun install-sh libmysqlclient.def Makefile.* \
+					mysql++.* osver Wishlist $(PKGNAME)
+            </command>
+
+			<!-- VC++ project file subdirs -->
+			<command>
+				for d in vc200? ; do \
+					mkdir -p $(PKGNAME)/$(DDD) ; \
+					cp $(DDD)/*.{sln,vcproj} $(PKGNAME)/$(DDD) ; \
+				done
+			</command>
+
+            <!-- config subdir -->
+            <command>cp config/*.m4 $(PKGNAME)/config</command>
+
+            <!-- doc subdir -->
+            <if cond="BUILDDOCS=='yes'">
+				<command>
+					cp -RL doc/README* doc/pdf doc/ssqls-pretty $(PKGNAME)/doc
+				</command>
+				<command>
+					for f in LICENSE.txt Makefile mktxt README.txt \*.{dbx,in,xsl} ; \
+					do \
+						cp doc/userman/$(DDF) $(PKGNAME)/doc/userman ; \
+					done
+				</command>
+				<command>
+					for d in refman userman ; do \
+						for f in *.{css,html} ; do \
+							cp doc/html/$(DDD)/$(DDF) $(PKGNAME)/doc/html/$(DDD) ; \
+						done ; \
+					done
+				</command>
+				<command>
+					cp doc/html/refman/*.png $(PKGNAME)/doc/html/refman
+				</command>
+			</if>
+            <if cond="BUILDDOCS!='yes'">
+				<!-- We have to copy this file even though we don't
+				     build the docs to make configure happy, because it
+					 wants to update the version number. -->
+				<command>
+					cp doc/userman/userman.dbx.in $(PKGNAME)/doc/userman
+				</command>
+			</if>
+
+            <!-- examples subdir -->
+            <command>
+                cp examples/*.{cpp,h,jpg} $(PKGNAME)/examples
+            </command>
+            <command>
+                for d in mfc wforms ; \
+                do \
+                    mkdir -p $(PKGNAME)/examples/vstudio/$(DDD) ; \
+                    cp examples/vstudio/$(DDD)/*.{cpp,h,r*,vcproj} \
+                        $(PKGNAME)/examples/vstudio/$(DDD) ; \
+                done
+            </command>
+
+            <!-- lib subdir -->
+            <command>
+                cp lib/*.{cpp,h,in,pl} $(PKGNAME)/lib
+            </command>
+
+            <!-- test subdir -->
+            <command>
+                cp test/*.cpp $(PKGNAME)/test
+            </command>
+
+            <!-- re-bootstrap it to get a standard configuration -->
+            <command>cd $(PKGNAME) ; ./bootstrap nodoc nomaint</command>
+            <command>rm -f $(PKGNAME)/Makefile $(PKGNAME)/config.{log,status}</command>
+            <command>rm -fr $(PKGNAME)/autom4te.cache</command>
+        </action>
+
+		<action id="dist">
+            <depends>$(PKGNAME)</depends>
+            <command>tar czf $(PKGNAME).tar.gz $(PKGNAME)</command>
+            <command>rm -rf $(PKGNAME)</command>
+        </action>
+
+        <action id="rpm">
+            <if cond="BUILDDOCS=='yes'">
+                <depends>doc</depends>
+            </if>
+            <depends>dist</depends>
+            <command>cp $(PKGNAME).tar.gz /usr/src/redhat/SOURCES</command>
+            <command>cd /usr/src/redhat/SPECS</command>
+            <command>rpmbuild -ba mysql++.spec</command>
+        </action>
+
+        <action id="ebuild">
+            <depends>dist</depends>
+            <command>cp $(PKGNAME).tar.gz /usr/portage/distfiles</command>
+            <command>
+                cp mysql++.ebuild /usr/portage/dev-db/mysql++/$(PKGNAME).ebuild
+            </command>
+            <command>
+                ebuild /usr/portage/dev-db/mysql++/$(PKGNAME).ebuild digest
+            </command>
+        </action>
+    </if>
+</makefile>

ADDED   mysql++.ebuild
Index: mysql++.ebuild
==================================================================
--- /dev/null
+++ mysql++.ebuild
@@ -0,0 +1,43 @@
+# Copyright 1999-2004 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+inherit gcc eutils gnuconfig
+
+DESCRIPTION="C++ API interface to the MySQL database"
+# This is the download page but includes links to other places
+HOMEPAGE="http://tangentsoft.net/mysql++/"
+SRC_URI_BASE="http://tangentsoft.net/mysql++/releases"
+SRC_URI="${SRC_URI_BASE}/${P}.tar.gz"
+
+LICENSE="LGPL-2"
+SLOT="0"
+KEYWORDS="x86 ~alpha ~hppa ~mips ~sparc ~ppc ~amd64"
+IUSE=""
+
+DEPEND=">=dev-db/mysql-3.23.49"
+
+src_unpack() {
+	unpack ${P}.tar.gz
+}
+
+src_compile() {
+	gnuconfig_update
+	# not including the directives to where MySQL is because it seems to find it
+	# just fine without
+	# force the cflags into place otherwise they get totally ignored by
+	# configure
+	CFLAGS="${CFLAGS}" CXXFLAGS="${CFLAGS} ${CXXFLAGS}" econf || \
+			die "econf failed"
+
+	emake || die "unable to make"
+}
+
+src_install() {
+	make DESTDIR=${D} install || die
+	# install the docs and HTML pages
+	dodoc README* LICENSE.txt
+	dodoc doc/*
+	dohtml doc/html/*
+	prepalldocs
+}
+

ADDED   mysql++.spec.in
Index: mysql++.spec.in
==================================================================
--- /dev/null
+++ mysql++.spec.in
@@ -0,0 +1,169 @@
+Summary:    C++ wrapper for the MySQL C API
+Name:       @PACKAGE_NAME@
+Version:    @PACKAGE_VERSION@
+Release:    1%{?dist}
+License:    LGPL
+Group:      Development/Libraries
+URL:        http://tangentsoft.net/mysql++/
+Source0:    http://tangentsoft.net/mysql++/releases/mysql++-%{version}.tar.gz
+BuildRoot:  %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
+BuildRequires: mysql-devel
+
+%description
+MySQL++ makes working with MySQL server queries as easy as working
+with STL containers.  This package contains only the libraries needed to
+run MySQL++-based programs.  If you are building your own MySQL++-based
+programs, you also need to install the -devel package.
+
+%package devel
+Summary:   MySQL++ developer files (headers, examples, etc.)
+Group:     Development/Libraries
+Requires:  mysql++ = %{version}-%{release}, mysql-devel
+
+%description devel
+These are the files needed to compile MySQL++ based programs, plus
+some sample code to get you started.  If you aren't building your own
+programs, you probably don't need to install this package.
+
+%package manuals
+Summary:   MySQL++ user and reference manuals
+Group:     Development/Libraries
+
+%description manuals
+This is the MySQL++ documentation.  It's a separate RPM just because
+it's so large, and it doesn't change with every release.
+
+%prep
+%setup -q
+
+# Fakery for nodoc case
+if [ ! -e doc/README-devel-RPM.txt ]
+then
+	touch doc/README-devel-RPM.txt
+	touch doc/README-doc-RPM.txt
+	touch doc/README-manuals-RPM.txt
+	%{__mkdir_p} doc/html doc/pdf
+fi
+
+%build
+%configure --disable-dependency-tracking
+%{__make} %{?_smp_mflags}
+
+%install
+rm -rf %{buildroot} doc/examples
+
+%{__mkdir_p} %{buildroot}{%{_libdir},%{_includedir}}
+
+%{__make} DESTDIR=%{buildroot} install
+
+# Copy example programs to doc directory
+%{__mkdir_p} doc/examples
+%{__install} -m644 examples/*.{cpp,h} doc/examples/
+%{__install} -m644 config.h doc/examples/
+sed -i -e s@../config.h@config.h@ doc/examples/threads.h
+
+# Fix up simple example Makefile to allow it to build on the install
+# system, as opposed to the system where the Makefile was created.
+%{__sed} -e 's@./examples/@@' \
+  -e 's@^CPPFLAGS :=.*$@CPPFLAGS := $(shell mysql_config --cflags)@' \
+  -e 's@^LDFLAGS :=.*$@LDFLAGS := $(shell mysql_config --libs)@' \
+  -e 's@ -Ilib@@' \
+  -e '/^all:/s/test_[a-z,_]* //g' \
+  Makefile.simple > doc/examples/Makefile
+
+%clean
+rm -rf %{buildroot} doc/examples
+
+%post -p /sbin/ldconfig 
+
+%postun -p /sbin/ldconfig
+
+%files
+%defattr(-,root,root,-)
+%doc ChangeLog COPYING.txt CREDITS.txt LICENSE.txt README.txt
+%{_libdir}/libmysqlpp.so.*
+
+%files devel
+%defattr(-,root,root,-)
+%doc doc/examples doc/README-devel-RPM.txt README-examples.txt Wishlist
+%{_includedir}/mysql++
+%{_libdir}/libmysqlpp.so
+
+%files manuals
+%defattr(-,root,root,-)
+%doc doc/html doc/pdf doc/README-manuals-RPM.txt
+
+%changelog
+* Mon Jul 2 2007 Warren Young <mysqlpp@etr-usa.com> 2.3.0-1
+- Reflected changes to doc dir layout in manuals sub-package
+
+* Mon Mar 19 2007 Warren Young <mysqlpp@etr-usa.com> 2.2.1-4
+- Reorganized locations of generated documentation
+
+* Mon Mar 19 2007 Warren Young <mysqlpp@etr-usa.com> 2.2.1-3
+- Merge of Remi Collet's spec file with official one
+
+* Sun Mar 18 2007 Remi Collet <rpms@FamilleCollet.com> 2.2.1-2
+- find perm on common.h
+- soname mysql++-2.2.1-bkl.patch
+
+* Wed Feb 28 2007 Remi Collet <rpms@FamilleCollet.com> 2.2.1-1
+- Initial spec for Extras
+
+* Wed Feb 28 2007 Remi Collet <rpms@FamilleCollet.com> 2.2.1-1.fc{3-6}.remi
+- update to version 2.2.1
+
+* Thu Jan 25 2007 Remi Collet <rpms@FamilleCollet.com> 2.2.0-1.fc{3-6}.remi
+- update to version 2.2.0
+
+* Mon Nov 13 2006 Remi Collet <rpms@FamilleCollet.com> 2.1.1.fc6.remi
+- FC6.x86_64 build
+- dynamic (sed) patch for Makefile (use mysql_config)
+
+* Thu Nov 02 2006 Remi Collet <rpms@FamilleCollet.com> 2.1.1.fc6.remi
+- FC6 build
+
+* Sat Apr  8 2006 Remi Collet <rpms@FamilleCollet.com> 2.1.1.fc{3,4,5}.remi
+- update to version 2.1.1
+
+* Sat Nov 26 2005 Remi Collet <remi.collet@univ-reims.fr> 2.0.7-1.fc3.remi - 2.0.7-1.fc4.remi
+- update to version 2.0.4
+- build with mysql-5.0.15 (requires libmysqlclient.so.15)
+
+* Sun Sep  4 2005 Remi Collet <remi.collet@univ-reims.fr> 2.0.4-1.FC4.remi
+- version 2.0.4
+
+* Sat Aug 20 2005 Remi Collet <remi.collet@univ-reims.fr> 2.0.2-1.FC4.remi
+- built for FC4
+- spec cleanning...
+
+* Thu Jun 16 2005 Remi Collet <Remi.Collet@univ-reims.fr> 1.7.40-1.FC3.remi
+- built for FC3 and MySQL 4.1.11
+- examples in /usr/share/doc/mysql++-%%{version}/examples
+
+* Sat Apr 30 2005 Warren Young <mysqlpp@etr-usa.com> 1.7.34-1
+- Split manuals out into their own sub-package.
+
+* Thu Mar 10 2005 Warren Young <mysqlpp@etr-usa.com> 1.7.32-1
+- Disabled building of examples, to speed RPM build.
+
+* Fri Nov 05 2004 Warren Young <mysqlpp@etr-usa.com> 1.7.21-1
+- Split out -devel subpackage, which now includes the examples
+
+* Wed Aug 18 2004 Warren Young <mysqlpp@etr-usa.com> 1.7.11-1
+- Removed examples from documentation.
+- Limited documentation to just the generated files, not the sources.
+
+* Wed Apr 16 2003 Tuan Hoang <tqhoang@bigfoot.com> 1.7.9-4
+- Added gcc 3.2.2 patch.
+- Packaged using Red Hat Linux 8.0 and 9.
+
+* Thu Nov 14 2002 Tuan Hoang <tqhoang@bigfoot.com> 1.7.9-3
+- Changed the version passed to libtool.
+
+* Mon Oct 28 2002 Tuan Hoang <tqhoang@bigfoot.com> 1.7.9-2
+- Updated the version numbering of the library to be 1.7.9.
+- Packaged using Red Hat Linux 8.0.
+
+* Thu Oct 17 2002 Philipp Berndt <philipp.berndt@gmx.net>
+- packaged

ADDED   osver
Index: osver
==================================================================
--- /dev/null
+++ osver
@@ -0,0 +1,16 @@
+#!/bin/sh
+if grep Red /etc/issue > /dev/null 2>&1
+then
+	echo -n rh
+	grep Red /etc/issue |cut -f5 -d' '
+elif grep Fedora /etc/issue > /dev/null 2>&1
+then
+	echo -n fc
+	grep Fedora /etc/issue |cut -f4 -d' '
+elif grep CentOS /etc/issue > /dev/null 2>&1
+then
+	echo -n el
+	grep CentOS /etc/issue |cut -f3 -d' ' |cut -f1 -d.
+else
+	echo UNKNOWN
+fi

ADDED   rebake.bat
Index: rebake.bat
==================================================================
--- /dev/null
+++ rebake.bat
@@ -0,0 +1,2 @@
+@echo on
+bakefile_gen %*

DELETED sqlplusint/Makefile.am
Index: sqlplusint/Makefile.am
==================================================================
--- sqlplusint/Makefile.am
+++ /dev/null
@@ -1,35 +0,0 @@
-include $(top_srcdir)/Configure
-
-EXTRA_DIST = custom.pl
-
-lib_LTLIBRARIES = libsqlplus.la
-
-libsqlplus_la_SOURCES = coldata.cc connection.cc datetime.cc field_names.cc \
-	field_types.cc manip.cc query.cc result.cc row.cc set.cc sql_query.cc \
-	type_info.cc vallist.cc
-
-libsqlplus_la_LDFLAGS = -version-info $(SQLPLUS_MAJOR_VERSION):$(SQLPLUS_MINOR_VERSION):$(SQLPLUS_MICRO_VERSION)
-
-noinst_HEADERS = magic.h tracker.h
-
-include_HEADERS = sqlplus.hh coldata1.hh coldata2.hh coldata3.hh coldata4.hh \
-	compare1.hh compare2.hh compare3.hh connection0.hh connection1.hh \
-	connection2.hh connection3.hh const_string1.hh const_string2.hh const_string3.hh \
-	convert1.hh convert2.hh convert3.hh custom-macros.hh custom.hh datetime1.hh \
-	datetime2.hh datetime3.hh field_names1.hh field_names2.hh field_names3.hh \
-	field_types1.hh field_types2.hh field_types3.hh fields1.hh fields2.hh \
-	manip1.hh manip2.hh manip3.hh null1.hh null2.hh null3.hh query1.hh query2.hh \
-	query3.hh resiter1.hh result1.hh result2.hh result3.hh row1.hh row2.hh \
-	row3.hh set1.hh set2.hh set3.hh sql_query0.hh sql_query1.hh sql_query2.hh \
-	sql_query3.hh sql_string1.hh sql_string2.hh sql_string3.hh stream2string1.hh \
-	stream2string2.hh stream2string3.hh tiny_int1.hh tiny_int2.hh tiny_int3.hh \
-	type_info1.hh type_info2.hh type_info3.hh vallist1.hh vallist2.hh vallist3.hh \
-	define_short defs
-
-all-local: custom.hh custom-macros.hh
-
-custom.hh custom-macros.hh: custom.pl
-	perl custom.pl
-
-distclean-local:
-	rm -f custom.hh custom-macros.hh

DELETED sqlplusint/Makefile.in
Index: sqlplusint/Makefile.in
==================================================================
--- sqlplusint/Makefile.in
+++ /dev/null
@@ -1,367 +0,0 @@
-# Makefile.in generated automatically by automake 1.4a from Makefile.am
-
-# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
-# This Makefile.in is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-
-
-SHELL = @SHELL@
-
-srcdir = @srcdir@
-top_srcdir = @top_srcdir@
-VPATH = @srcdir@
-prefix = @prefix@
-exec_prefix = @exec_prefix@
-
-bindir = @bindir@
-sbindir = @sbindir@
-libexecdir = @libexecdir@
-datadir = @datadir@
-sysconfdir = @sysconfdir@
-sharedstatedir = @sharedstatedir@
-localstatedir = @localstatedir@
-libdir = @libdir@
-infodir = @infodir@
-mandir = @mandir@
-includedir = @includedir@
-oldincludedir = /usr/local/include/
-
-DESTDIR =
-
-pkgdatadir = $(datadir)/@PACKAGE@
-pkglibdir = $(libdir)/@PACKAGE@
-pkgincludedir = $(includedir)/@PACKAGE@
-
-top_builddir = ..
-
-ACLOCAL = @ACLOCAL@
-AUTOCONF = @AUTOCONF@
-AUTOMAKE = @AUTOMAKE@
-AUTOHEADER = @AUTOHEADER@
-
-INSTALL = @INSTALL@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_DATA = @INSTALL_DATA@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_STRIP_FLAG =
-transform = @program_transform_name@
-
-NORMAL_INSTALL = :
-PRE_INSTALL = :
-POST_INSTALL = :
-NORMAL_UNINSTALL = :
-PRE_UNINSTALL = :
-POST_UNINSTALL = :
-host_alias = @host_alias@
-host_triplet = @host@
-AS = @AS@
-CC = @CC@
-CXX = @CXX@
-DLLTOOL = @DLLTOOL@
-LD = @LD@
-LIBTOOL = @LIBTOOL@
-LN_S = @LN_S@
-MAINT = @MAINT@
-MAKEINFO = @MAKEINFO@
-MYSQL_HOME = @MYSQL_HOME@
-NM = @NM@
-OBJDUMP = @OBJDUMP@
-PACKAGE = @PACKAGE@
-RANLIB = @RANLIB@
-SQLPLUS_MAJOR_VERSION = @SQLPLUS_MAJOR_VERSION@
-SQLPLUS_MICRO_VERSION = @SQLPLUS_MICRO_VERSION@
-SQLPLUS_MINOR_VERSION = @SQLPLUS_MINOR_VERSION@
-VERSION = @VERSION@
-
-INCLUDES = -Wall -I$(top_srcdir)/sqlplusint
-
-SQLPLUSLIBS = $(top_builddir)/sqlplusint/libsqlplus.la
-
-EXTRA_DIST = custom.pl
-
-lib_LTLIBRARIES = libsqlplus.la
-
-libsqlplus_la_SOURCES = coldata.cc connection.cc datetime.cc field_names.cc 	field_types.cc manip.cc query.cc result.cc row.cc set.cc sql_query.cc 	type_info.cc vallist.cc
-
-
-libsqlplus_la_LDFLAGS = -version-info $(SQLPLUS_MAJOR_VERSION):$(SQLPLUS_MINOR_VERSION):$(SQLPLUS_MICRO_VERSION)
-
-noinst_HEADERS = magic.h tracker.h
-
-include_HEADERS = sqlplus.hh coldata1.hh coldata2.hh coldata3.hh coldata4.hh 	compare1.hh compare2.hh compare3.hh connection0.hh connection1.hh 	connection2.hh connection3.hh const_string1.hh const_string2.hh const_string3.hh 	convert1.hh convert2.hh convert3.hh custom-macros.hh custom.hh datetime1.hh 	datetime2.hh datetime3.hh field_names1.hh field_names2.hh field_names3.hh 	field_types1.hh field_types2.hh field_types3.hh fields1.hh fields2.hh 	manip1.hh manip2.hh manip3.hh null1.hh null2.hh null3.hh query1.hh query2.hh 	query3.hh resiter1.hh result1.hh result2.hh result3.hh row1.hh row2.hh 	row3.hh set1.hh set2.hh set3.hh sql_query0.hh sql_query1.hh sql_query2.hh 	sql_query3.hh sql_string1.hh sql_string2.hh sql_string3.hh stream2string1.hh 	stream2string2.hh stream2string3.hh tiny_int1.hh tiny_int2.hh tiny_int3.hh 	type_info1.hh type_info2.hh type_info3.hh vallist1.hh vallist2.hh vallist3.hh 	define_short defs
-
-mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
-CONFIG_HEADER = ../config.h
-CONFIG_CLEAN_FILES = 
-LTLIBRARIES =  $(lib_LTLIBRARIES)
-
-
-DEFS = @DEFS@ -I. -I$(srcdir) -I..
-CPPFLAGS = @CPPFLAGS@
-LDFLAGS = @LDFLAGS@
-LIBS = @LIBS@
-libsqlplus_la_LIBADD = 
-libsqlplus_la_OBJECTS =  coldata.lo connection.lo datetime.lo \
-field_names.lo field_types.lo manip.lo query.lo result.lo row.lo set.lo \
-sql_query.lo type_info.lo vallist.lo
-CXXFLAGS = @CXXFLAGS@
-CXXCOMPILE = $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
-LTCXXCOMPILE = $(LIBTOOL) --mode=compile $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
-CXXLD = $(CXX)
-CXXLINK = $(LIBTOOL) --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(LDFLAGS) -o $@
-HEADERS =  $(include_HEADERS) $(noinst_HEADERS)
-
-DIST_COMMON =  README Makefile.am Makefile.in
-
-
-DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
-
-TAR = gtar
-GZIP_ENV = --best
-SOURCES = $(libsqlplus_la_SOURCES)
-OBJECTS = $(libsqlplus_la_OBJECTS)
-
-all: all-redirect
-.SUFFIXES:
-.SUFFIXES: .S .c .cc .lo .o .s
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) $(top_srcdir)/Configure
-	cd $(top_srcdir) && $(AUTOMAKE) --foreign --include-deps sqlplusint/Makefile
-
-Makefile: $(srcdir)/Makefile.in  $(top_builddir)/config.status
-	cd $(top_builddir) \
-	  && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
-
-
-mostlyclean-libLTLIBRARIES:
-
-clean-libLTLIBRARIES:
-	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
-
-distclean-libLTLIBRARIES:
-
-maintainer-clean-libLTLIBRARIES:
-
-install-libLTLIBRARIES: $(lib_LTLIBRARIES)
-	@$(NORMAL_INSTALL)
-	$(mkinstalldirs) $(DESTDIR)$(libdir)
-	@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
-	  if test -f $$p; then \
-	    echo "$(LIBTOOL)  --mode=install $(INSTALL) $$p $(DESTDIR)$(libdir)/$$p"; \
-	    $(LIBTOOL)  --mode=install $(INSTALL) $$p $(DESTDIR)$(libdir)/$$p; \
-	  else :; fi; \
-	done
-
-uninstall-libLTLIBRARIES:
-	@$(NORMAL_UNINSTALL)
-	list='$(lib_LTLIBRARIES)'; for p in $$list; do \
-	  $(LIBTOOL)  --mode=uninstall rm -f $(DESTDIR)$(libdir)/$$p; \
-	done
-
-.c.o:
-	$(COMPILE) -c $<
-
-.s.o:
-	$(COMPILE) -c $<
-
-.S.o:
-	$(COMPILE) -c $<
-
-mostlyclean-compile:
-	-rm -f *.o core *.core
-
-clean-compile:
-
-distclean-compile:
-	-rm -f *.tab.c
-
-maintainer-clean-compile:
-
-.c.lo:
-	$(LIBTOOL) --mode=compile $(COMPILE) -c $<
-
-.s.lo:
-	$(LIBTOOL) --mode=compile $(COMPILE) -c $<
-
-.S.lo:
-	$(LIBTOOL) --mode=compile $(COMPILE) -c $<
-
-mostlyclean-libtool:
-	-rm -f *.lo
-
-clean-libtool:
-	-rm -rf .libs _libs
-
-distclean-libtool:
-
-maintainer-clean-libtool:
-
-libsqlplus.la: $(libsqlplus_la_OBJECTS) $(libsqlplus_la_DEPENDENCIES)
-	$(CXXLINK) -rpath $(libdir) $(libsqlplus_la_LDFLAGS) $(libsqlplus_la_OBJECTS) $(libsqlplus_la_LIBADD) $(LIBS)
-.cc.o:
-	$(CXXCOMPILE) -c $<
-.cc.lo:
-	$(LTCXXCOMPILE) -c $<
-
-install-includeHEADERS: $(include_HEADERS)
-	@$(NORMAL_INSTALL)
-	$(mkinstalldirs) $(DESTDIR)$(includedir)
-	@list='$(include_HEADERS)'; for p in $$list; do \
-	  if test -f "$$p"; then d= ; else d="$(srcdir)/"; fi; \
-	  echo " $(INSTALL_DATA) $$d$$p $(DESTDIR)$(includedir)/$$p"; \
-	  $(INSTALL_DATA) $$d$$p $(DESTDIR)$(includedir)/$$p; \
-	done
-
-uninstall-includeHEADERS:
-	@$(NORMAL_UNINSTALL)
-	list='$(include_HEADERS)'; for p in $$list; do \
-	  rm -f $(DESTDIR)$(includedir)/$$p; \
-	done
-
-tags: TAGS
-
-ID: $(HEADERS) $(SOURCES) $(LISP)
-	list='$(SOURCES) $(HEADERS)'; \
-	unique=`for i in $$list; do echo $$i; done | \
-	  awk '    { files[$$0] = 1; } \
-	       END { for (i in files) print i; }'`; \
-	here=`pwd` && cd $(srcdir) \
-	  && mkid -f$$here/ID $$unique $(LISP)
-
-TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) $(LISP)
-	tags=; \
-	here=`pwd`; \
-	list='$(SOURCES) $(HEADERS)'; \
-	unique=`for i in $$list; do echo $$i; done | \
-	  awk '    { files[$$0] = 1; } \
-	       END { for (i in files) print i; }'`; \
-	test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
-	  || (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags  $$unique $(LISP) -o $$here/TAGS)
-
-mostlyclean-tags:
-
-clean-tags:
-
-distclean-tags:
-	-rm -f TAGS ID
-
-maintainer-clean-tags:
-
-distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)
-
-subdir = sqlplusint
-
-distdir: $(DISTFILES)
-	@for file in $(DISTFILES); do \
-	  d=$(srcdir); \
-	  if test -d $$d/$$file; then \
-	    cp -pr $$d/$$file $(distdir)/$$file; \
-	  else \
-	    test -f $(distdir)/$$file \
-	    || ln $$d/$$file $(distdir)/$$file 2> /dev/null \
-	    || cp -p $$d/$$file $(distdir)/$$file || :; \
-	  fi; \
-	done
-
-info-am:
-info: info-am
-dvi-am:
-dvi: dvi-am
-check-am: all-am
-check: check-am
-installcheck-am:
-installcheck: installcheck-am
-install-exec-am: install-libLTLIBRARIES
-install-exec: install-exec-am
-
-install-data-am: install-includeHEADERS
-install-data: install-data-am
-
-install-am: all-am
-	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
-install: install-am
-uninstall-am: uninstall-libLTLIBRARIES uninstall-includeHEADERS
-uninstall: uninstall-am
-all-am: Makefile $(LTLIBRARIES) $(HEADERS) all-local
-all-redirect: all-am
-install-strip:
-	$(MAKE) $(AM_MAKEFLAGS) INSTALL_STRIP_FLAG=-s install
-installdirs:
-	$(mkinstalldirs)  $(DESTDIR)$(libdir) $(DESTDIR)$(includedir)
-
-
-mostlyclean-generic:
-
-clean-generic:
-
-distclean-generic:
-	-rm -f Makefile $(CONFIG_CLEAN_FILES)
-	-rm -f config.cache config.log stamp-h stamp-h[0-9]*
-
-maintainer-clean-generic:
-mostlyclean-am:  mostlyclean-libLTLIBRARIES mostlyclean-compile \
-		mostlyclean-libtool mostlyclean-tags \
-		mostlyclean-generic
-
-mostlyclean: mostlyclean-am
-
-clean-am:  clean-libLTLIBRARIES clean-compile clean-libtool clean-tags \
-		clean-generic mostlyclean-am
-
-clean: clean-am
-
-distclean-am:  distclean-libLTLIBRARIES distclean-compile \
-		distclean-libtool distclean-tags distclean-generic \
-		clean-am distclean-local
-	-rm -f libtool
-
-distclean: distclean-am
-
-maintainer-clean-am:  maintainer-clean-libLTLIBRARIES \
-		maintainer-clean-compile maintainer-clean-libtool \
-		maintainer-clean-tags maintainer-clean-generic \
-		distclean-am
-	@echo "This command is intended for maintainers to use;"
-	@echo "it deletes files that may require special tools to rebuild."
-
-maintainer-clean: maintainer-clean-am
-
-.PHONY: mostlyclean-libLTLIBRARIES distclean-libLTLIBRARIES \
-clean-libLTLIBRARIES maintainer-clean-libLTLIBRARIES \
-uninstall-libLTLIBRARIES install-libLTLIBRARIES mostlyclean-compile \
-distclean-compile clean-compile maintainer-clean-compile \
-mostlyclean-libtool distclean-libtool clean-libtool \
-maintainer-clean-libtool uninstall-includeHEADERS \
-install-includeHEADERS tags mostlyclean-tags distclean-tags clean-tags \
-maintainer-clean-tags distdir info-am info dvi-am dvi check check-am \
-installcheck-am installcheck install-exec-am install-exec \
-install-data-am install-data install-am install uninstall-am uninstall \
-all-local all-redirect all-am all installdirs mostlyclean-generic \
-distclean-generic clean-generic maintainer-clean-generic clean \
-mostlyclean distclean maintainer-clean
-
-
-all-local: custom.hh custom-macros.hh
-
-custom.hh custom-macros.hh: custom.pl
-	perl custom.pl
-
-perlclean: 
-	-rm -f custom-macros.hh custom.hh
-
-distclean-local:
-	rm -f custom.hh custom-macros.hh
-	
-classref: *1.hh
-	-rm -f .perceps doc.sgml
-	perceps -N *1.hh
-
-# Tell versions [3.59,3.63) of GNU make to not export all variables.
-# Otherwise a system limit (for SysV at least) may be exceeded.
-.NOEXPORT:

DELETED sqlplusint/README
Index: sqlplusint/README
==================================================================
--- sqlplusint/README
+++ /dev/null
@@ -1,37 +0,0 @@
-All of the header files in this dir (sqlplusint) are internal.  This
-means that you should never include any of these directly in your
-programs as they are subject to change from one relese to another.
-
-For those interesting in improving the code the files are laid out in
-the following fashion:
-
-name0.hh: Header files ending in a 0.hh generally cantains macro
-  defantions and other messy stuff.
-name1.hh: Header files ending in 1.hh contain just the class as
-  functions declartions and really simple inline functions.  A 1.hh
-  header file should never include anything but other 1.hh header
-  files.
-name2.hh: Header files ending in 2.hh contain inline functions and 
-  methods.  They should generally only include other 1.hh or 2.hh
-  header files however they may also include 3.hh and 4.hh header
-  files if, for example, they want to instantiate the nessary template
-  functions.
-name3.hh: Header files ending in 3.hh contain non-inline template 
-  functions and methods.
-name4.hh: Header files ending in 4.hh contain template functions in
-  which are the nessary instances should already be instanstaed.  Thus
-  these should never be included in the end users program.  Only
-  within other 4.hh or .cc files in this directory.
-name.cc: These contain the actual functions and methods coresponding
-  the the appreate header file.  They may include templates procided
-  that the nessary instances will all be instantiated by the end of
-  the .cc file
-
-The name1.hh, name2.hh, and name3.hh are all garentied to exists if
-atleast one of them exists so that I don't have to worry about
-checking if they exists.  They files may contain nothing but 
-  #include"name<prev number.hh" 
-however.
-
-I chose this format to miminze interdependencies and to help better
-orginaize my code.

DELETED sqlplusint/coldata.cc
Index: sqlplusint/coldata.cc
==================================================================
--- sqlplusint/coldata.cc
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <string>
-#include "const_string3.hh"
-#include "coldata4.hh"
-
-template class mysql_ColData<string>;
-template class mysql_ColData<const_string>;

DELETED sqlplusint/coldata1.hh
Index: sqlplusint/coldata1.hh
==================================================================
--- sqlplusint/coldata1.hh
+++ /dev/null
@@ -1,110 +0,0 @@
-#ifndef __coldata1_hh__
-#define __coldata1_hh__
-
-#include <typeinfo>
-#include <string>
-#include "defs"
-#include "type_info1.hh"
-#include "const_string1.hh"
-#include "null1.hh"
-
-//! with_class = mysql_ColData
-
-//: Exception structure thrown when a bad conversion takes place
-struct BadConversion {
-  const char*  type_name;  //:
-  const string data;       //:
-  size_t       retrieved;  //:
-  size_t       actual_size;//:
-  BadConversion(const char* tn, const char* d, size_t r, size_t a)
-    : type_name(tn), data(d), retrieved(r), actual_size(a) {};
-};
-
-//: Base class for auto-converting column data.  Do not use directly. 
-//
-// A smart string. It will automatically convert it self to any of the
-// basic C types. 
-//
-// When used with binary operators it will
-// automatically convert it self to the type used on the other side of
-// the operator if it is a basic type.
-//
-// However, be careful when using it with binary operators as. 
-// 
-// MysqlStr("12.86") + 2
-// 
-// will return 14 because 2 is an integer. What you wanted to say was 
-//
-// MysqlStr("12.86") + 2.0
-//
-// If this type of thing scares you define the micro NO_BINARY_OPERS
-// to turn of this behavior.
-//
-// This class also has some basic information about the type of data
-// stored in it.
-//
-// <bf>Do not use this class directly.</bf>
-//  Use the typedef ColData or MutableColData instead.
-template <class Str>
-class mysql_ColData : public Str {
-private:
-  mysql_type_info _type;
-	string buf;
-public:
-  mysql_ColData (mysql_type_info t = mysql_type_info::string_type) 
-    : _type(t) {}
-  mysql_ColData (const char *str, 
-		 mysql_type_info t = mysql_type_info::string_type)
-    : Str(str), _type(t) {buf=(string)str;}
-
-  mysql_type_info type() {return _type;}
-  //: Returns the current mysql type of current item
-
-  bool quote_q() const {return _type.quote_q();}
-  //: Returns true or false depending on if the data is of a type that
-  //: should be quoted
-
-  bool escape_q() const {return _type.escape_q();}
-  //: Returns true of false depending on if the data is of a type that
-  //: should be escaped
-  
-  template<class Type> Type conv (Type dummy) const;
-
-  //!dummy: operator TYPE() const;
-  //: Converts the column data to TYPE.
-  // If all the charters are not read during the conversion to TYPE it
-  // will through BadConversion.
-  //
-  // TYPE is defined for all the build in types.
-  //
-  // (Note, This is not an actual template)
-
-  operator cchar*() const {return buf.c_str();}
-  operator  signed char() const {return conv((signed char)0);}
-  operator  unsigned char() const {return conv((unsigned char)0);}
-  operator  int() const {return conv((int)0);}
-  operator  unsigned int() const {return conv((unsigned int)0);}
-  operator  short int() const {return conv((short int)0);}
-  operator  unsigned short int() const {return conv((unsigned short int)0);}
-  operator  long int() const {return conv((long int)0);}
-  operator  unsigned long int() const {return conv((unsigned long int)0);}
-#ifndef NO_LONG_LONGS
-  operator  long long int() const {return conv((long long int)0);}
-  operator  unsigned long long int() const {return conv((unsigned long long int)0);}
-#endif
-  operator  float() const {return conv((float)0);}
-  operator  double() const {return conv((double)0);}
-
-  template <class T, class B> operator Null<T,B> () const;
-};
-
-//: The Type that is returned by constant rows
-typedef mysql_ColData<const_string> ColData;
-//: The Type that is returned by mutable rows
-typedef mysql_ColData<string>       MutableColData;
-//: For backwards compatibility. Do not use.
-typedef ColData MysqlString;
-//: For backwards compatibility. Do not use.
-typedef ColData MysqlStr;
-
-#endif

DELETED sqlplusint/coldata2.hh
Index: sqlplusint/coldata2.hh
==================================================================
--- sqlplusint/coldata2.hh
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef __coldata2_hh__
-#define __coldata2_hh__
-
-#include <stdlib.h>
-#include "coldata1.hh"
-
-#ifndef NO_BINARY_OPERS
-
-#define oprsw(opr, other, conv) \
-  template<class Str> \
-  inline other operator opr (mysql_ColData<Str> x, other y) \
-    {return (conv)x opr y;} \
-  template<class Str> \
-  inline other operator opr (other x, mysql_ColData<Str> y) \
-    {return x opr (conv)y;}
-
-#define operator_binary(other, conv) \
-  oprsw(+, other, conv) \
-  oprsw(-, other, conv) \
-  oprsw(*, other, conv) \
-  oprsw(/, other, conv) 
-
-#define operator_binary_int(other, conv) \
-  operator_binary(other, conv) \
-  oprsw(%, other, conv) \
-  oprsw(&, other, conv) \
-  oprsw(^, other, conv) \
-  oprsw(|, other, conv) \
-  oprsw(<<, other, conv) \
-  oprsw(>>, other, conv) 
-
-operator_binary(float, double)
-operator_binary(double, double)
-
-operator_binary_int(char,long int)
-operator_binary_int(int, long int)
-operator_binary_int(short int, long int)
-operator_binary_int(long int, long int)
-
-operator_binary_int(unsigned char, unsigned long int)
-operator_binary_int(unsigned int, unsigned long int)
-operator_binary_int(unsigned short int, unsigned long int)
-operator_binary_int(unsigned long int, unsigned long int)
-
-#ifndef NO_LONG_LONGS
-operator_binary_int(long long int, long long int)
-operator_binary_int(unsigned long long int, unsigned long long int)
-#endif 
-
-#endif // NO_BINARY_OPERS
-
-#endif

DELETED sqlplusint/coldata3.hh
Index: sqlplusint/coldata3.hh
==================================================================
--- sqlplusint/coldata3.hh
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef __coldata3_hh__
-#define __coldata3_hh__
-#ifdef __WIN32__
-#include <Windows32/Base.h>
-#include <Windows32/Defines.h>
-#include <Windows32/Structures.h>
-#include <winsock.h>
-#define errno WSAGetLastError()
-#endif
-#include <mysql.h>
-#include <string>
-#include "coldata2.hh"
-#include "convert3.hh"
-#include "null3.hh"
-
-template <class Str> template <class T, class B> 
-mysql_ColData<Str>::operator Null<T,B> () const {
-  if ((*this)[0] == 'N' && (*this)[1] == 'U' && 
-      (*this)[2] == 'U' && (*this)[3] == 'L' && size() == 4)
-    return Null<T,B>(null);
-  else return Null<T,B>(conv(T()));
-}
-
-#endif

DELETED sqlplusint/coldata4.hh
Index: sqlplusint/coldata4.hh
==================================================================
--- sqlplusint/coldata4.hh
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef __coldata4_h__
-#define __coldata4_h__
-
-#include "convert3.hh"
-
-#include "coldata3.hh"
-
-template <class Str> template<class Type> 
-Type mysql_ColData<Str>::conv (Type dummy) const {
-  size_t len = size();
-  const char *str = c_str();
-  const char *end = str;
-  Type num = mysql_convert<Type>(str, end);
-  if (*end == '.') {
-    end++;
-    for (;*end == '0'; end++);
-  }
-  if (*end != '\0' && end != NULL ) {
-    throw BadConversion (typeid(Type).name(), c_str(), end - str, len);
-  }
-  return num;
-}
-
-#endif

DELETED sqlplusint/compare1.hh
Index: sqlplusint/compare1.hh
==================================================================
--- sqlplusint/compare1.hh
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef __compare1_hh__
-#define __compare1_hh__
-
-#include <function.h>
-#include "row1.hh"
-
-template <class BinaryPred, class CmpType>
-class MysqlCmp : public unary_function<const MysqlRow&, bool>
-{
-protected:
-  unsigned int index;
-  BinaryPred   func;
-  CmpType      cmp2;
-public:
-  MysqlCmp(uint i, const BinaryPred &f, const CmpType &c) : index(i),func(f),cmp2(c) {}
-  bool operator () (const MysqlRow& cmp1) const {return func(cmp2,cmp1[index]);}
-};
-
-template <class BinaryPred>
-class MysqlCmpCStr : public MysqlCmp<BinaryPred, const char *>
-{
-public:
-  MysqlCmpCStr(uint i, const BinaryPred &f, const char* c) : MysqlCmp<BinaryPred, const char *> (i,f,c) {}
-  bool operator () (const MysqlRow& cmp1) const 
-    {return func(cmp2,cmp1[index]);}
-};
-
-//: A special function for using in find_if function where i is the field index number.
-// This is a more generic form of mysql_cmp_cstr will work with any
-// CmpType that MysqlString can convert to.  However, this is not
-// neary as effecent.  Only use when obsoletely nessary.
-template <class BinaryPred, class CmpType>
-MysqlCmp <BinaryPred, CmpType>
-mysql_cmp(uint i, const BinaryPred &func, const CmpType &cmp2)
-{
-  return MysqlCmp<BinaryPred, CmpType>(i, func, cmp2);
-}
-
-typedef binary_function<const char*, const char*, bool> bin_char_pred;
-
-struct cstr_equal_to : bin_char_pred {
-  bool operator () (const char *x, const char *y) const
-    {return !strcmp(x,y);}
-};
-struct cstr_not_equal_to : bin_char_pred {
-  bool operator () (const char *x, const char *y) const
-    {return strcmp(x,y);}
-};
-struct cstr_less : bin_char_pred {
-  bool operator () (const char *x, const char *y) const
-    {return strcmp(x,y) > 0; }
-};
-struct cstr_less_equal : bin_char_pred {
-  bool operator () (const char *x, const char *y) const
-    {return strcmp(x,y) >= 0; }
-};
-struct cstr_greater : bin_char_pred {
-  bool operator () (const char *x, const char *y) const
-    {return strcmp(x,y) < 0; }
-};
-struct cstr_greater_equal : bin_char_pred {
-  bool operator () (const char *x, const char *y) const
-    {return strcmp(x,y) <= 0; }
-};
-
-//:A special function for using in find_if fucntion where i is the field index
-//:number.
-//
-// func should be one of cstr_equal_to(), cstr_not_equal_to(),
-// cstr_less(), cstr_less_equal(), cstr_less_equal(), cstr_less_equal().
-template <class BinaryPred>
-MysqlCmpCStr <BinaryPred>
-mysql_cmp_cstr (uint i, const BinaryPred &func, const char *cmp2) {
-  return MysqlCmpCStr<BinaryPred>(i, func, cmp2);
-}
-
-#endif

DELETED sqlplusint/compare2.hh
Index: sqlplusint/compare2.hh
==================================================================
--- sqlplusint/compare2.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "compare1.hh"

DELETED sqlplusint/compare3.hh
Index: sqlplusint/compare3.hh
==================================================================
--- sqlplusint/compare3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "compare2.hh"

DELETED sqlplusint/connection.cc
Index: sqlplusint/connection.cc
==================================================================
--- sqlplusint/connection.cc
+++ /dev/null
@@ -1,152 +0,0 @@
-
-#include "connection3.hh"
-#include "result3.hh"
-
-// pointer_tracker<MYSQL,Connection>  Connection::others = pointer_tracker<MYSQL, Connection>();
-
-Connection::Connection (const char *db, const char *host, const char *user, 
-			const char *passwd, bool te) 
-  : throw_exceptions(te), locked(false)
-{
-	mysql_init(&mysql);
-  connect (db, host, user, passwd);
-//  others.insert(&mysql,this);
-}
-
-Connection::Connection (const char *db, const char *host, const char *user, 
-			const char *passwd, uint port, my_bool compress,
-			unsigned int connect_timeout, bool te,
-			const char *socket_name)
-  : throw_exceptions(te), locked(false)
-{
-	mysql_init(&mysql);
-  real_connect (db, host, user, passwd, port, compress,
-		connect_timeout,socket_name);
-//  others.insert(&mysql,this);
-}
-
-bool Connection::real_connect (cchar *db, cchar *host, cchar *user,
-			       cchar *passwd, uint port, my_bool compress,
-			       unsigned int connect_timeout,
-			       const char *socket_name)
-{
-  if (socket_name && socket_name[0])
-    mysql.options.unix_socket = (char *)socket_name;
-  else
-    mysql.options.unix_socket=NULL;
-  mysql.options.port = port;
-  mysql.options.compress = compress;
-  mysql.options.connect_timeout=connect_timeout;
-  locked = true; 
-  if (mysql_connect(&mysql, host, user, passwd))
-  {
-    locked = false;
-    Success = is_connected = true;
-  }
-  else
-  {
-    locked = false; Success = is_connected = false;
-    if (throw_exceptions) throw BadQuery(error());
-  }
-  if (!Success) return Success;
-  if (db[0]) // if db is not empty
-    Success = select_db(db);
-  return Success;
-}
-
-Connection::~Connection () {
-  for (set<MysqlChild*>::iterator i = children.begin(); 
-       i != children.end();
-       i++) 
-    {
-      (*i)->parent_leaving();
-    }
-	mysql_close(&mysql);
-//  others.remove(&mysql,this); 
-}
-
-bool Connection::select_db (const char *db) {
-  bool suc = !(mysql_select_db(&mysql, db));
-  if (throw_exceptions && !suc) throw MysqlBadQuery(error());
-  else return suc;
-}
-
-bool Connection::reload() {
-  bool suc = !mysql_reload(&mysql);
-  if (throw_exceptions && !suc) throw MysqlBadQuery(error());
-  else return suc;
-}
-
-bool Connection::shutdown () {
-  bool suc = !(mysql_shutdown(&mysql));
-  if (throw_exceptions && !suc) throw MysqlBadQuery(error());
-  else return suc;
-}  
-
-bool Connection::connect (cchar *db, cchar *host, cchar *user, cchar *passwd) {
-  locked = true;
-  if (mysql_connect(&mysql, host, user, passwd)) {
-    locked = false;
-    Success = is_connected = true;
-  } else {
-    locked = false;
-    if (throw_exceptions) throw BadQuery(error());
-    Success = is_connected = false;
-  }
-  if (!Success) return Success;
-  if (db[0]) // if db is not empty
-    Success = select_db(db);
-  return Success;
-}
-
-string Connection::info () {
-  char *i = mysql_info(&mysql);
-  if (!i)
-    return string();
-  else
-    return string(i);
-}
-
-ResNSel Connection::execute(const string &str, bool throw_excptns) {
-  Success = false;
-  if (lock()) 
-    if (throw_excptns) throw BadQuery(error());
-    else return ResNSel();
-  Success = !mysql_query(&mysql, str.c_str()); 
-  unlock();
-  if (!Success) 
-    if (throw_excptns) throw BadQuery(error());
-    else return ResNSel();
-  return ResNSel(this);
-}
-
-Result Connection::store(const string &str, bool throw_excptns) {
-  Success = false;
-  if (lock()) 
-    if (throw_excptns) throw BadQuery(error());
-    else return Result();
-  Success = !mysql_query(&mysql, str.c_str()); 
-  unlock();
-  if (!Success) 
-    if (throw_excptns) throw BadQuery(error());
-    else return Result();
-  return Result(mysql_store_result(&mysql));
-}
-  
-ResUse Connection::use(const string &str, bool throw_excptns) {
-  Success = false;
-  if (lock()) 
-    if (throw_excptns) throw BadQuery(error());
-    else return ResUse();
-  Success = !mysql_query(&mysql, str.c_str()); 
-  if (!Success) 
-    if (throw_excptns) throw BadQuery(error());
-    else return ResUse();
-  return ResUse(mysql_use_result(&mysql), this);
-}
-
-void Connection::storein(MutableRes& con, const string &s) {
-  con = use(s);
-}
-
-

DELETED sqlplusint/connection0.hh
Index: sqlplusint/connection0.hh
==================================================================
--- sqlplusint/connection0.hh
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef __connection0_hh__
-#define __connection0_hh__
-
-class MysqlChild {
-public:
-  virtual void parent_leaving() = 0;
-  virtual ~MysqlChild() {}
-};
-
-#endif
-
-
-

DELETED sqlplusint/connection1.hh
Index: sqlplusint/connection1.hh
==================================================================
--- sqlplusint/connection1.hh
+++ /dev/null
@@ -1,164 +0,0 @@
-#ifndef __connection1_hh__
-#define __connection1_hh__
-#ifdef __WIN32__
-#include <Windows32/Base.h>
-#include <Windows32/Defines.h>
-#include <Windows32/Structures.h>
-#include <winsock.h>
-#define errno WSAGetLastError()
-#endif
-#include <mysql.h>
-#include <vector.h>
-#include <deque.h>
-#include <list.h>
-#include <slist.h>
-#include <set.h>
-#include <map.h>
-#include <multiset.h>
-#include "define_short"
-#include "query1.hh"
-#include "result1.hh"
-
-#include "connection0.hh" 
-#include "tracker.h"
-
-//: Exception thrown when a BadQuery is encountered
-struct BadQuery {
-  BadQuery(string er) : error(er) {}
-  string error; //: The error message
-};
-
-class MutableRes;
-
-//: The main database handle
-class Connection {
-  friend ResNSel;
-  friend ResUse;
-  friend Query;
-  
-private:
-  set<MysqlChild*> children;
-//  static pointer_tracker<MYSQL, Connection> others;
-  
-  bool throw_exceptions;
-  MYSQL mysql;
-  bool is_connected;
-  bool locked;
-  bool Success;
-
-  int          affected_rows()  {return mysql_affected_rows((MYSQL*) &mysql);}
-  int          insert_id () {return mysql_insert_id(&mysql);}
-
-public:
-  Connection () : throw_exceptions(false), locked(false) //:
-    {/* others.insert(&mysql,this);*/	mysql_init(&mysql);}
-  Connection (bool te) : throw_exceptions(te), is_connected(false), locked(false), Success(false) //:
-    {/*others.insert(&mysql,this);*/	mysql_init(&mysql);}
-  Connection (const char *db, const char *host = "", const char *user = "", 
-	      const char *passwd = "", bool te = false); 
-  Connection (const char *db, const char *host, const char *user, 
-	      const char *passwd = "", uint port = 3306, my_bool compress = 1,
-	      unsigned int connect_timeout = 5, bool te = false,
-	      cchar *socket_name = "");
-
-  bool   real_connect (cchar *db = "", cchar *host = "", 
-		       cchar *user = "", cchar *passwd = "", uint port = 0,
-		       my_bool compress = 0, unsigned int connect_timeout = 60,
-		       cchar *socket_name= "");
-				
-  ~Connection (); //:
-  void         close() {mysql_close(&mysql);}	
-  string       info ();	
-
-  bool   connected() const {return is_connected;}
-  //: returns true if a successful connection was made
-
-  bool   success() {return Success;}
-  //: returns true of the last query was successful
-
-  bool   connect (cchar *db = "", cchar *host = "", 
-		  cchar *user = "", cchar *passwd = "");
-  //:
-
-  bool   lock() {if (locked) return true; locked = true; return false;}
-  void   unlock() {locked = false;}
-
-  void purge (MYSQL *m) {mysql_close(&mysql); }
-  //:
-
-  void add_child(MysqlChild *child) {children.insert(child);}
-  //:
-
-  void remove_child(MysqlChild *child) {children.erase(child); }
-  //: 
-
-  inline Query query();
-  //:
-
-  operator bool () {return success();}                  //: returns success()
-  string error () {return string(mysql_error(&mysql));} //: last error message()
-	int errnum () {return mysql_errno(&mysql);}
-	int   refresh (unsigned int refresh_options){ return mysql_refresh (&mysql,refresh_options); }
-	int ping (void) { return mysql_ping(&mysql);}
-	int kill (unsigned long pid) { return mysql_kill (&mysql,pid);}
-  string clinet_info () {return string(mysql_get_client_info());} //:
-  
-  string host_info () {return string(mysql_get_host_info(&mysql));} //:
-  
-  int    proto_info () {return mysql_get_proto_info(&mysql);} //:
-  
-  string server_info () {return string(mysql_get_server_info(&mysql));} //:
- 
-  string stat() {return string(mysql_stat(&mysql));} //:
- 
-  Result  store(const string &str) {return store(str, throw_exceptions);} //:
-  ResUse  use(const string &str)   {return use(str, throw_exceptions);} //:
-  ResNSel execute(const string &str) {return execute(str, throw_exceptions);} //:
-  Result  store(const string &str, bool te); //:
-  ResUse  use(const string &str, bool te); //:
-  ResNSel execute(const string &str, bool te); //:
- 
-  bool   create_db (string db) {return !(execute( "CREATE DATABASE " + db ));} //:
-  bool   drop_db (string db) {return !(execute( "DROP DATABASE " + db ));} //:
-  bool   select_db (string db) {return select_db(db.c_str());} //:
-  bool   select_db (const char *db); //:
-  bool   reload(); //:
-  bool   shutdown (); //:
-	string infoo (void) {return info ();}
-	st_mysql_options get_options (void) const {return mysql.options;}
-	int read_options(enum mysql_option option,const char *arg) {return  mysql_options(&mysql, option,arg);}
-
-  template <class Sequence> void storein_sequence(Sequence &, const string &); //:
-  template <class Set>      void storein_set(Set &, const string &);  //:
-
-  //!dummy: void storein(TYPE &con, const string &s);
-  //: Stores the results in TYPE.  
-  // Stores the result in TYPE. TYPE must be some sort of STL container.  
-
-                            void storein(MutableRes &con, const string &s);
-  template <class T>        void storein(vector<T> &con, const string &s)
-    {storein_sequence(con,s);}
-  template <class T>        void storein(deque<T> &con, const string &s)
-     {storein_sequence(con,s);}
-  template <class T>        void storein(list<T> &con, const string &s)
-    {storein_sequence(con,s);}
-  template <class T>        void storein(slist<T> &con, const string &s)
-    {storein_sequence(con,s);}
-  template <class T>        void storein(set<T> &con, const string &s)
-    {storein_set(con,s);}
-  template <class T>        void storein(multiset<T> &con, const string &s)
-    {storein_set(con,s);}
-};
-
-
-//! with_class = Connection
-
-//: For backwards companablity, don't use
-typedef Connection Mysql;
-
-#endif
-
-
-
-
-

DELETED sqlplusint/connection2.hh
Index: sqlplusint/connection2.hh
==================================================================
--- sqlplusint/connection2.hh
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef __connection2_hh__
-#define __connection2_hh__
-
-#include "connection1.hh"
-#include "query2.hh"
-
-inline Query Connection::query() {return Query(this, throw_exceptions);}
-
-template <class Sequence>
-void Connection::storein_sequence (Sequence &seq, const string &str) {
-  ResUse result = use(str);
-  while (1) {
-	  MYSQL_ROW d = mysql_fetch_row(result.mysql_res);
-		if (!d) break;
-	  Row row(d,&result,true);
-		if (!row) break;
-    seq.push_back(typename Sequence::value_type(row));
-	}
-}
-
-template <class Set>
-void Connection::storein_set (Set &sett, const string &str) {
-  ResUse result = use(str);
-	while (1) {
-	  MYSQL_ROW d = mysql_fetch_row(result.mysql_res);	
-		if (!d) return;
-	  Row row(d,&result,true);
-		if (!row) break;
-    sett.insert(typename Set::value_type(row));
-	}
-}
-
-
-#endif

DELETED sqlplusint/connection3.hh
Index: sqlplusint/connection3.hh
==================================================================
--- sqlplusint/connection3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "connection2.hh"

DELETED sqlplusint/const_string1.hh
Index: sqlplusint/const_string1.hh
==================================================================
--- sqlplusint/const_string1.hh
+++ /dev/null
@@ -1,115 +0,0 @@
-#ifndef __const_string1_hh__
-#define __const_string1_hh__
-
-#include <stdexcept>
-#include <string>
-#include <iostream>
-
-//: A special string that is created from a existing const char *
-// It contains a small subset of the standard string class.  When an
-// object is created only a link to the const char * is created.  The
-// data is NOT copied.  thus the const char * needs to stick around
-// for the life of the class.
-class const_string {
-private:
-  const char *str_data; 
-public:
-  typedef const char   value_type;      //:
-  typedef unsigned int size_type;       //:
-  typedef          int difference_type; //:
-
-  typedef const char&     const_reference; //:
-  typedef const_reference reference;       //:
-  typedef const char*     const_pointer;   //:
-  typedef const_pointer   pointer;         //:
-
-  typedef const char*    const_iterator;   //:
-  typedef const_iterator iterator;         
-  //: The same as const_iterator because the data can not be changed.
-  
-  const_string() : str_data("") {}                  //:
-  const_string(const char *str) : str_data(str) {}  //:
-  const_string& operator = (const char *str)        //:
-    {str_data = str; return *this;}
- 
-  size_type size() const //: 
-  { register int i = 0;
-    while (str_data[i]) i++;
-    return i;
-  }
-
-  const_iterator  begin() const {return str_data;}          //:
-  const_iterator  end()   const {return str_data + size();} //:
-
-  size_type length() const {return size();}   //:
-  size_type max_size() const {return size();} //:
-  
-  const_reference operator[](size_type pos) const {return str_data[pos];} //:
-  const_reference at(size_type pos) const //: 
-  {
-    if (pos >= size()) throw out_of_range("");
-    else return str_data[pos];
-  }
-  
-  const char* c_str() const {return str_data;} //:
-  const char* data()  const {return str_data;} //:
-  
-  int compare(const const_string& str) const //:
-  {
-    const char* str1 = str_data;
-    const char* str2 = str.str_data;
-    while (*str1 == *str2 && (*str1 || *str2)) {str1++; str2++;}
-    return *str1-*str2;
-  }
-};
-
-
-//! with_class = const_string
-
-//:
-inline ostream& operator << (ostream &o, const const_string &str) {
-  return o << str.c_str();
-}
-
-//:
-inline int compare (const const_string &lhs, const const_string &rhs) {
-  return lhs.compare(rhs);
-}
-
-//:
-inline bool operator == (const_string &lhs, const_string &rhs) {
-  return compare(lhs,rhs) == 0;
-}
-
-//:
-inline bool operator != (const_string &lhs, const_string &rhs) {
-  return compare(lhs,rhs) != 0;
-}
-
-//:
-inline bool operator < (const_string &lhs, const_string &rhs) {
-  return compare(lhs,rhs) < 0;
-}
-
-//:
-inline bool operator <= (const_string &lhs, const_string &rhs) {
-  return compare(lhs,rhs) <= 0;
-}
-
-//:
-inline bool operator > (const_string &lhs, const_string &rhs) {
-  return compare(lhs,rhs) > 0;
-}
-
-//:
-inline bool operator >= (const_string &lhs, const_string &rhs) {
-  return compare(lhs,rhs) >= 0;
-}
-
-#endif
-
-  
- 
-  
-  
-  

DELETED sqlplusint/const_string2.hh
Index: sqlplusint/const_string2.hh
==================================================================
--- sqlplusint/const_string2.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "const_string1.hh"

DELETED sqlplusint/const_string3.hh
Index: sqlplusint/const_string3.hh
==================================================================
--- sqlplusint/const_string3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "const_string2.hh"

DELETED sqlplusint/convert1.hh
Index: sqlplusint/convert1.hh
==================================================================
--- sqlplusint/convert1.hh
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef __convert1_hh__
-#define __convert1_hh__
-
-#include <stdlib.h>
-
-template <class Type> class mysql_convert;
-
-#define mysql__convert(TYPE, FUNC) \
-  template <> \
-  class mysql_convert<TYPE> {\
-  private:\
-    TYPE num;\
-  public:\
-    mysql_convert(const char* str, const char *& end) { \
-      num = FUNC(str, const_cast<char **>(&end));}\
-    operator TYPE () {return num;}\
-  };\
-
-mysql__convert(float, strtod)
-mysql__convert(double, strtod)
-
-#undef mysql__convert
-#define mysql__convert(TYPE, FUNC) \
-  template <> \
-  class mysql_convert<TYPE> {\
-  private:\
-    TYPE num;\
-  public:\
-    mysql_convert(const char* str, const char *& end) { \
-      num = FUNC(str, const_cast<char **>(&end),10);}\
-    operator TYPE () {return num;}\
-  };\
-
-mysql__convert(char, strtol)
-mysql__convert(signed char, strtol)
-mysql__convert(int, strtol)
-mysql__convert(short int, strtol)
-mysql__convert(long int, strtol)
-
-mysql__convert(unsigned char, strtoul)
-mysql__convert(unsigned int, strtoul)
-mysql__convert(unsigned short int, strtoul)
-mysql__convert(unsigned long int, strtoul)
-
-#ifndef NO_LONG_LONGS
-mysql__convert(long long int, strtoll)
-mysql__convert(unsigned long long int, strtoull)
-#endif
-
-#endif
-
-
-

DELETED sqlplusint/convert2.hh
Index: sqlplusint/convert2.hh
==================================================================
--- sqlplusint/convert2.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "convert1.hh"

DELETED sqlplusint/convert3.hh
Index: sqlplusint/convert3.hh
==================================================================
--- sqlplusint/convert3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "convert2.hh"

DELETED sqlplusint/custom.pl
Index: sqlplusint/custom.pl
==================================================================
--- sqlplusint/custom.pl
+++ /dev/null
@@ -1,826 +0,0 @@
-
-open (OUT0, ">custom.hh");
-open (OUT, ">custom-macros.hh");
-
-print OUT0 << "---";
-
-// This file is generated from the perl script custom.pl, please do 
-// not modify this file directly.
-
-#ifndef __sql_custom_h__
-#define __sql_custom_h__
-
-enum sql_dummy_type {sql_dummy};
-enum sql_cmp_type {sql_use_compare};
-
-inline int sql_cmp(const string &a, const string &b) {
-  return a.compare(b);
-}
----
-
-@types = ("char", "unsigned char", "tiny_int", "int", "unsigned int",
-	  "short int", "unsigned short int");
-foreach $type (@types) {
-    print OUT0 << "---";
-
-inline int sql_cmp($type a,$type b) {
-  return a-b;
-}
----
-}
-
-@types = ("double", "float");
-foreach $type (@types) {
-    print OUT0 << "---";
-
-inline int sql_cmp($type a,$type b) {
-  if (a == b) return 0;
-  if (a <  b) return -1;
-  return 1;
-}
----
-}	
-
-print OUT0 << "---";
-
-#ifndef NO_LONG_LONGS
----
-
-@types = ("long long", "unsigned long long");
-foreach $type (@types) {
-    print OUT0 << "---";
-
-inline int sql_cmp($type a,$type b) {
-  if (a == b) return 0;
-  if (a <  b) return -1;
-  return 1;
-}
----
-}	
-
-print OUT0 << "---";
-
-#endif // NO_LONG_LONGS
-
-#include "custom-macros.hh"
-
-#endif
-
----
-
-print OUT << "---";
-
-// This file is generated from the perl script custom.pl, please do 
-// not modify this file directly unless you wish to cut out unnessary
-// macros.
-
-// ---------------------------------------------------
-//                Begin Mandatory Compare 
-// ---------------------------------------------------
-
-#define sql_compare_define(NAME) \\
-    bool operator == (const NAME &other) const \\
-      {return sql_compare_##NAME##<sql_dummy>(*this,other) == 0;} \\
-    bool operator != (const NAME &other) const \\
-      {return sql_compare_##NAME##<sql_dummy>(*this,other) != 0;} \\
-    bool operator > (const NAME &other) const \\
-      {return sql_compare_##NAME##<sql_dummy>(*this,other) >  0;} \\
-    bool operator < (const NAME &other) const \\
-      {return sql_compare_##NAME##<sql_dummy>(*this,other) <  0;} \\
-    bool operator >= (const NAME &other) const \\
-      {return sql_compare_##NAME##<sql_dummy>(*this,other) >= 0;} \\
-    bool operator <= (const NAME &other) const \\
-      {return sql_compare_##NAME##<sql_dummy>(*this,other) <= 0;} \\
-    int cmp (const NAME &other) const \\
-      {return sql_compare_##NAME##<sql_dummy>(*this,other);} \\
-    int compare (const NAME &other) const \\
-      {return sql_compare_##NAME##<sql_dummy>(*this,other);}
----
-
-foreach $j (1..26) {
-    $parm0 .= "T$j, C$j";
-    $parm0 .= ", " unless $j == 26;
-    $parm1 .= "C$j";
-    $parm1 .= ", " unless $j == 26;
-}
-
-print OUT << "---";
-
-#define sql_compare_define_0(NAME, $parm0)
-
-#define sql_construct_define_0(NAME, $parm0)
-
-#define sql_COMPARE__0(NAME, $parm1)
-
-#define sql_compare_type_def_0(NAME, WHAT, NUM) \\
-  sql_compare_type_def_##NUM (NAME, WHAT, NUM)
-
-#define sql_compare_type_defe_0(NAME, WHAT, NUM) \\
-  sql_compare_type_defe_##NUM (NAME, WHAT, NUM)
-
-// ---------------------------------------------------
-//                 End Mandatory Compare 
-// ---------------------------------------------------
----
-
-foreach $i (1..26) {
-  $compr = ""; $parm2 = ""; $define = "";
-  $compr = "    int cmp; \\\n" unless $i == 1;
-  $compp = "";
-  foreach $j (1..$i) {
-      $compr .= "    if (cmp = sql_cmp(x.##C$j , y.##C$j )) return cmp; \\\n"
-                                                              unless $j == $i;
-      $compr .= "    return sql_cmp(x.##C$j , y.##C$j );"   if $j == $i;
-      $parm2 .= "const T$j &p$j";
-      $parm2 .= ", "  unless $j == $i;
-      $define.= "C$j (p$j)";
-      $define.= ", "  unless $j == $i;
-      $set   .= "    C$j = p$j;\\\n";
-      $compp .= "true";
-      $compp .= ", " unless $j == $i;
-  }
-  print OUT << "---";
-
-// ---------------------------------------------------
-//                   Begin Compare $i
-// ---------------------------------------------------
-
-#define sql_compare_define_$i(NAME, $parm0) \\
-  NAME ($parm2) : $define {} \\
-  void set  ($parm2) { \\
-$set \\
-  } \\
-  sql_compare_define(NAME)
-
-#define sql_construct_define_$i(NAME, $parm0) \\
-  void set  ($parm2) { \\
-$set \\
-  } \\
-  NAME ($parm2) : $define {}
-
-#define sql_compare_type_def_$i(NAME, WHAT, NUM) \\
-  return WHAT##_list(d, m, $compp)
-
-#define sql_compare_type_defe_$i(NAME, WHAT, NUM) \\
-  return WHAT##_list(d, c, m, $compp)
-
-#define sql_COMPARE__$i(NAME, $parm1) \\
-  template <sql_dummy_type dummy> \\
-  int sql_compare_##NAME (const NAME &x, const NAME &y) { \\
-$compr \\
-  } \\
-  template <sql_dummy_type dummy> \\
-  int compare (const NAME &x, const NAME &y) { \\
-$compr \\
-  }
-
-// ---------------------------------------------------
-//                   End Compare $i
-// ---------------------------------------------------
-
----
-}
-
-print OUT << "---";
----
-
-
-foreach $i (1..26) {
-    $parm_complete = ""; 
-    $parm_order = ""; $parm_order2c = "";
-    $parm_simple = ""; $parm_simple2c = "";
-    $parm_simple_b = ""; $parm_simple2c_b = "";
-    $parm_names = ""; $parm_names2c = "";
-    $defs = ""; $popul = ""; $parmc = ""; $parmC = "";
-    $value_list = ""; $field_list = ""; $equal_list = "";
-    $value_list_cus = ""; $cus_field_list = ""; $cus_equal_list = "";
-    $create_bool = ""; $create_list = "";
-    $cusparms1 = ""; $cusparms2 = ""; $cusparmsv = "";    
-    $cusparms11 = ""; $cusparms22 = "";
-    $names = "";$enums = "";
-    foreach $j (1 .. $i) {
-        $parm_complete .= "T$j, I$j, N$j, O$j";
-	$parm_complete .= ", " unless $j == $i;
-	$parm_order    .= "T$j, I$j, O$j";
-	$parm_order    .= ", " unless $j == $i;
-        $parm_order2c  .= "T$j, I$j, #I$j, O$j";
-	$parm_order2c  .= ", " unless $j == $i;
-        $parm_names    .= "T$j, I$j, N$j";
-	$parm_names    .= ", " unless $j == $i;
-	$parm_names2c  .= "T$j, I$j, N$j, ". ($j-1);
-	$parm_names2c  .= ", " unless $j == $i;
-	$parm_simple   .= "T$j, I$j";
-	$parm_simple   .= ", " unless $j == $i;
-	$parm_simple2c .= "T$j, I$j, #I$j, ". ($j-1);
-	$parm_simple2c .= ", " unless $j == $i;
-	$parm_simple_b   .= "T$j, I$j";
-	$parm_simple_b   .= ", " unless $j == $i;
-	$parm_simple2c_b .= "T$j, I$j, ". ($j-1);
-	$parm_simple2c_b .= ", " unless $j == $i;
-	$defs  .= "    T$j I$j;";
-	$defs  .= "\n" unless $j == $i;
-	$popul .= "    s->##I$j = row[ O$j ];";
-	$popul .= "\n" unless $j == $i;
-        $names .= "    N$j ";
-	$names .= ",\n" unless $j == $i;
-        $enums .= "    NAME##_##I$j";
-	$enums .= ",\n" unless $j == $i;
-        $field_list .= "    s << obj.manip << obj.obj->names[".($j-1)."]";
-	$field_list .= " << obj.delem;\n" unless $j == $i;
-	$value_list .= "    s << obj.manip << obj.obj->##I$j";
-	$value_list .= " << obj.delem;\n" unless $j == $i;
-        $create_bool .= "    if (i$j) (*include)[".($j-1)."]=true;\n";
-        $create_list .= "    if (i$j == NAME##_NULL) return;\n" unless $i == 1;
-        $create_list .= "    (*include)[i$j]=true;\n";
-
-        $value_list_cus .= "    if ((*obj.include)[".($j-1)."]) { \n";
-	$value_list_cus .= "      if (before) s << obj.delem;\n" unless $j == 1;
-        $value_list_cus .= "      s << obj.manip << obj.obj->##I$j;\n";
-	$value_list_cus .= "      before = true; \n" unless $j == $i;
-	$value_list_cus .= "     } \n";
-
-        $cus_field_list .= "    if ((*obj.include)[".($j-1)."]) { \n";
-	$cus_field_list .= "      if (before) s << obj.delem;\n" unless $j == 1;
-        $cus_field_list .= "      s << obj.manip << obj.obj->names[".($j-1)."];\n";
-	$cus_field_list .= "      before = true; \n" unless $j == $i;
-	$cus_field_list .= "     } \n";
-
-        $cus_equal_list .= "    if ((*obj.include)[".($j-1)."]) { \n";
-	$cus_equal_list .= "      if (before) s << obj.delem;\n" unless $j == 1;
-        $cus_equal_list .= "      s << obj.obj->names[".($j-1)."] << obj.comp";
-        $cus_equal_list .=        " << obj.manip << obj.obj->##I$j;\n";
-	$cus_equal_list .= "      before = true; \n" unless $j == $i;
-	$cus_equal_list .= "     } \n";
-
-        $equal_list .= "    s << obj.obj->names[".($j-1)."] << obj.comp";
-        $equal_list .= " << obj.manip << obj.obj->##I$j";
-	$equal_list .= " << obj.delem;\n" unless $j == $i;
-        $cusparms1  .= "bool i$j"         if     $j == 1;
-	$cusparms1  .= "bool i$j = false" unless $j == 1;
-	$cusparms1  .= ", " unless $j == $i;
-        $cusparms11  .= "bool i$j" ;
-	$cusparms11  .= ", " unless $j == $i;
-	$cusparms2  .= "##NAME##_enum i$j" if $j == 1;
-	$cusparms2  .= "##NAME##_enum i$j = ##NAME##_NULL" unless $j == 1;
-	$cusparms2  .= ", " unless $j == $i;
-	$cusparms22  .= "##NAME##_enum i$j";
-	$cusparms22  .= ", " unless $j == $i;
-        $cusparmsv  .= "i$j";
-	$cusparmsv  .= ", " unless $j == $i;
-	$parmC .= "T$j, I$j";
-	$parmC .= ", " unless $j == 26;
-        $parmc .= "I$j";
-	$parmc .= ", " unless $j == 26;
-    }
-    foreach $j ($i+1 .. 26) {
-	$parmC .= "0, 0";
-	$parmC .= ", " unless $j == 26;
-        $parmc .= "0";
-	$parmc .= ", " unless $j == 26;
-    }
-
-    print OUT << "---";
-// ---------------------------------------------------
-//                  Begin Create $i
-// ---------------------------------------------------
----
-    $out = <<"---";
-#define sql_create_basic_c_order_$i(NAME, CMP, CONTR, $parm_order)
-
-  struct NAME; 
-
-  template <sql_dummy_type dummy> int sql_compare_##NAME (const NAME &, const NAME &);
-
-  struct NAME { 
-$defs 
-    NAME () {} 
-    NAME (const MysqlRow &row);
-    sql_compare_define_##CMP(NAME, $parmC)
-  }; 
-
-  template <sql_dummy_type dummy> 
-    void populate_##NAME (NAME *s, const MysqlRow &row) { 
-$popul 
-  } 
-
-  inline NAME##::##NAME (const MysqlRow &row) 
-    {populate_##NAME##<sql_dummy>(this, row);} 
-
-  sql_COMPARE__##CMP##(NAME, $parmc )
----
-    print OUT &prepare($out);
-
-    $out = <<"---";
-#define sql_create_complete_$i(NAME, CMP, CONTR, $parm_complete) 
-  struct NAME; 
-
-  enum NAME##_enum { 
-$enums 
-    ,NAME##_NULL 
-  }; 
-
-  template <class Manip>
-  class NAME##_value_list { 
-  /*friend ostream& operator << <> (ostream&, const NAME##_value_list&); */
-  public: 
-    const NAME *obj;
-    cchar *delem;
-    Manip manip;
-  public: 
-    NAME##_value_list (const NAME *o, cchar *d, Manip m) 
-      : obj(o), delem(d), manip(m) {} 
-  };
-
-  template <class Manip>
-  class NAME##_##field_list {
-  /* friend ostream& operator << <> (ostream&, const NAME##_field_list&); */
-  public: 
-    const NAME *obj; 
-    cchar *delem;
-    Manip manip;
-  public: 
-    NAME##_field_list (const NAME *o, cchar *d, Manip m) 
-      : obj(o), delem(d), manip(m) {} 
-  };
-
-  template <class Manip>
-  class NAME##_equal_list { 
-  /* friend ostream& operator << <> (ostream&, const NAME##_equal_list&); */
-  public: 
-    const NAME *obj;
-    cchar *delem;
-    cchar *comp;
-    Manip manip;
-  public: 
-    NAME##_equal_list (const NAME *o, cchar *d, cchar *c, Manip m) 
-      : obj(o), delem(d), comp(c), manip(m) {}
-  };
-
-  template <class Manip>
-  class NAME##_cus_value_list {
-  /* friend ostream& operator << <> (ostream&, 
-  				  const NAME##_cus_value_list<Manip>&); */
-  public:
-    const NAME *obj;
-    cchar *delem;
-    Manip manip;
-    vector<bool> *include;
-    bool del_vector;
-  public: 
-    ~##NAME##_cus_value_list () {if (del_vector) delete include;} 
-    NAME##_cus_value_list (const NAME *o, cchar *d, Manip m, $cusparms11);
-    NAME##_cus_value_list (const NAME *o, cchar *d, Manip m, $cusparms22); 
-    NAME##_cus_value_list (const NAME *o, cchar *d, Manip m ,vector<bool>)
-      : obj(o), include(i), del_vector(false), delem(d), manip(m) {}
-  };
-
-  template <class Manip>
-  class NAME##_cus_field_list { 
-  /* friend ostream& operator << <> (ostream&, 
-     				  const NAME##_cus_field_list<Manip>&); */
-  public:
-    const NAME *obj; 
-    cchar *delem;
-    Manip manip;
-    vector<bool> *include; 
-    bool del_vector; 
-  public: 
-    ~##NAME##_cus_field_list () {if (del_vector) delete include;} 
-    NAME##_cus_field_list (const NAME *o, cchar *d, Manip m, $cusparms11); 
-    NAME##_cus_field_list (const NAME *o, cchar *d, Manip m, $cusparms22); 
-    NAME##_cus_field_list (const NAME *o, cchar *d, Manip m, vector<bool> *i) 
-      : obj(o), include(i), del_vector(false), delem(d), manip(m) {}
-  };
-
- template <class Manip>
- class NAME##_cus_equal_list {
- /* friend ostream& operator << <> (ostream&, 
-				  const NAME##_cus_equal_list<Manip>&); */
-  public:
-    const NAME *obj;
-    vector<bool> *include;
-    bool del_vector;
-    cchar *delem;
-    cchar *comp;
-    Manip manip;
-  public:
-    ~##NAME##_##cus_equal_list () {if (del_vector) delete include;}
-    NAME##_##cus_equal_list (const NAME *o, cchar *d, cchar *c, Manip m, $cusparms11); 
-    NAME##_##cus_equal_list (const NAME *o, cchar *d, cchar *c, Manip m, $cusparms22); 
-    NAME##_##cus_equal_list (const NAME *o, cchar *d, cchar *c, Manip m, vector<bool> *i) 
-      : obj(o), include(i), del_vector(false), delem(d), comp(c), manip(m) {}
-  };
-
-  template <sql_dummy_type dummy> int sql_compare_##NAME (const NAME &, const NAME &);
-
-  struct NAME { 
-$defs 
-    NAME () {} 
-    NAME (const MysqlRow &row);
-    void set (const MysqlRow &row);
-    sql_compare_define_##CMP(NAME, $parmC)
-    sql_construct_define_##CONTR(NAME, $parmC)
-    static char *names[];
-    static char *_table;
-    static char *& table() {return _table;}
-
-    NAME##_value_list<quote_type0> value_list() const {
-      return value_list(",", mysql_quote);}
-    NAME##_value_list<quote_type0> value_list(cchar *d) const {
-      return value_list(d, mysql_quote);}
-    template <class Manip> 
-    NAME##_value_list<Manip> value_list(cchar *d, Manip m) const; 
-
-    NAME##_field_list<do_nothing_type0> field_list() const {
-      return field_list(",", mysql_do_nothing);}
-    NAME##_field_list<do_nothing_type0> field_list(cchar *d) const {
-      return field_list(d, mysql_do_nothing);}
-    template <class Manip>
-    NAME##_field_list<Manip> field_list(cchar *d, Manip m) const; 
-
-    NAME##_equal_list<quote_type0> equal_list(cchar *d = ",", 
-                                              cchar *c = " = ") const{
-      return equal_list(d, c, mysql_quote);}
-    template <class Manip>
-    NAME##_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m) const; 
-    
-    /* cus_data */
-
-    NAME##_cus_value_list<quote_type0> value_list($cusparms1) const {
-      return value_list(",", mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_value_list<quote_type0> value_list($cusparms2) const {
-      return value_list(",", mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_value_list<quote_type0> value_list(vector<bool> *i) const {
-      return value_list(",", mysql_quote, i);
-    }
-    NAME##_cus_value_list<quote_type0> value_list(sql_cmp_type sc) const {
-      return value_list(",", mysql_quote, sc);
-    }
-
-    NAME##_cus_value_list<quote_type0> value_list(cchar *d, $cusparms1) const {
-      return value_list(d, mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_value_list<quote_type0> value_list(cchar *d, $cusparms2) const {
-      return value_list(d, mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_value_list<quote_type0> value_list(cchar *d, 
-						vector<bool> *i) const {
-      return value_list(d, mysql_quote, i);
-    }
-    NAME##_cus_value_list<quote_type0> value_list(cchar *d, 
-						sql_cmp_type sc) const {
-      return value_list(d, mysql_quote, sc);
-    }
-
-    template <class Manip>
-    NAME##_cus_value_list<Manip> value_list(cchar *d, Manip m,
-					  $cusparms1) const; 
-    template <class Manip>
-    NAME##_cus_value_list<Manip> value_list(cchar *d, Manip m,
-					  $cusparms2) const; 
-    template <class Manip>
-    NAME##_cus_value_list<Manip> value_list(cchar *d, Manip m, 
-					  vector<bool> *i) const;
-    template <class Manip>
-    NAME##_cus_value_list<Manip> value_list(cchar *d, Manip m, 
-					  sql_cmp_type sc) const;
-    /* cus field */
-
-    NAME##_cus_field_list<do_nothing_type0> field_list($cusparms1) const {
-      return field_list(",", mysql_do_nothing, $cusparmsv);
-    }
-    NAME##_cus_field_list<do_nothing_type0> field_list($cusparms2) const {
-      return field_list(",", mysql_do_nothing, $cusparmsv);
-    }
-    NAME##_cus_field_list<do_nothing_type0> field_list(vector<bool> *i) const {
-      return field_list(",", mysql_do_nothing, i);
-    }
-    NAME##_cus_field_list<do_nothing_type0> field_list(sql_cmp_type sc) const
-    {
-      return field_list(",", mysql_do_nothing, sc);
-    }
-
-    NAME##_cus_field_list<do_nothing_type0> field_list(cchar *d, 
-						       $cusparms1) const {
-      return field_list(d, mysql_do_nothing, $cusparmsv);
-    }
-    NAME##_cus_field_list<do_nothing_type0> field_list(cchar *d,
-						       $cusparms2) const {
-      return field_list(d, mysql_do_nothing, $cusparmsv);
-    }
-    NAME##_cus_field_list<do_nothing_type0> field_list(cchar *d, 
-						vector<bool> *i) const {
-      return field_list(d, mysql_do_nothing, i);
-    }
-    NAME##_cus_field_list<do_nothing_type0> field_list(cchar *d, 
-						sql_cmp_type sc) const {
-      return field_list(d, mysql_do_nothing, sc);
-    }
-
-    template <class Manip>
-    NAME##_cus_field_list<Manip> field_list(cchar *d, Manip m,
-					    $cusparms1) const; 
-    template <class Manip>
-    NAME##_cus_field_list<Manip> field_list(cchar *d, Manip m,
-					    $cusparms2) const; 
-    template <class Manip>
-    NAME##_cus_field_list<Manip> field_list(cchar *d, Manip m,
-					    vector<bool> *i) const;
-    template <class Manip>
-    NAME##_cus_field_list<Manip> field_list(cchar *d, Manip m, 
-					    sql_cmp_type sc) const;
-
-    /* cus equal */
-
-    NAME##_cus_equal_list<quote_type0> equal_list($cusparms1) const {
-      return equal_list(",", " = ", mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list($cusparms2) const {
-      return equal_list(",", " = ", mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list(vector<bool> *i) const {
-      return equal_list(",", " = ", mysql_quote, i);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list(sql_cmp_type sc) const {
-      return equal_list(",", " = ", mysql_quote, sc);
-    }
-
-    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, $cusparms1) const {
-      return equal_list(d, " = ", mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, $cusparms2) const {
-      return equal_list(d, " = ", mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, 
-						vector<bool> *i) const {
-      return equal_list(d, " = ", mysql_quote, i);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, 
-						sql_cmp_type sc) const {
-      return equal_list(d, " = ", mysql_quote, sc);
-    }
-
-    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, cchar *c,
-                                                $cusparms1) const {
-      return equal_list(d, c, mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, cchar *c,
-                                                $cusparms2) const {
-      return equal_list(d, c, mysql_quote, $cusparmsv);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, cchar *c,
-						vector<bool> *i) const {
-      return equal_list(d, c, mysql_quote, i);
-    }
-    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, cchar *c,
-						sql_cmp_type sc) const {
-      return equal_list(d, c, mysql_quote, sc);
-    }
-
-    template <class Manip>
-    NAME##_cus_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m, 
-					    $cusparms1) const; 
-    template <class Manip>
-    NAME##_cus_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m, 
-					    $cusparms2) const; 
-    template <class Manip>
-    NAME##_cus_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m, 
-					    vector<bool> *i) const;
-    template <class Manip>
-    NAME##_cus_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m, 
-					    sql_cmp_type sc) const;
-  }; 
-
-  char *##NAME##::names[] = { 
-$names 
-  }; 
-  char *##NAME##::_table = #NAME ;  
-
-  template <class Manip>
-  NAME##_cus_value_list<Manip>::NAME##_cus_value_list
-  (const NAME *o, cchar *d, Manip m, $cusparms11) 
-  { 
-    delem = d;
-    manip = m;
-    del_vector = true;
-    obj = o; 
-    include = new vector<bool>($i, false);
-$create_bool 
-  } 
-
-  template <class Manip>
-  NAME##_cus_value_list<Manip>::NAME##_cus_value_list
-  (const NAME *o, cchar *d, Manip m, $cusparms22) { 
-    delem = d;
-    manip = m;
-    del_vector = true; 
-    obj = o; 
-    include = new vector<bool>($i, false); 
-$create_list 
-  }
-
-  template <class Manip>
-  NAME##_cus_field_list<Manip>::NAME##_cus_field_list
-  (const NAME *o, cchar *d, Manip m, $cusparms11) {
-    delem = d;
-    manip = m;
-    del_vector = true; 
-    obj = o; 
-    include = new vector<bool>($i, false); 
-$create_bool 
-  } 
-
-  template <class Manip>
-  NAME##_cus_field_list<Manip>::NAME##_cus_field_list
-  (const NAME *o, cchar *d, Manip m, $cusparms22) { 
-    delem = d;
-    manip = m;
-    del_vector = true; 
-    obj = o; 
-    include = new vector<bool>($i, false); 
-$create_list 
-  }
-
-  template <class Manip>
-  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list
-  (const NAME *o, cchar *d, cchar *c, Manip m, $cusparms11) { 
-    delem = d;
-    comp = c;
-    manip = m;
-    del_vector = true; 
-    obj = o; 
-    include = new vector<bool>($i, false); 
-$create_bool 
-  } 
-
-  template <class Manip>
-  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list
-  (const NAME *o, cchar *d, cchar *c, Manip m, $cusparms22) { 
-    delem = d;
-    comp = c;
-    manip = m;
-    del_vector = true; 
-    obj = o; 
-    include = new vector<bool>($i, false); 
-$create_list 
-  }
-
-  template <class Manip>
-  ostream& operator << (ostream& s, const NAME##_value_list<Manip>& obj) { 
-$value_list; 
-    return s; 
-  } 
-
-  template <class Manip>
-  ostream& operator << (ostream& s, const NAME##_field_list<Manip>& obj) { 
-$field_list; 
-    return s; 
-  } 
-
-  template <class Manip>
-  ostream& operator << (ostream& s, const NAME##_equal_list<Manip>& obj) { 
-$equal_list; 
-    return s; 
-  } 
-
-  template <class Manip>
-  ostream& operator << (ostream& s, const NAME##_cus_value_list<Manip>& obj) { 
-    bool before = false; 
-$value_list_cus 
-    return s; 
-  } 
-
-  template <class Manip>
-  ostream& operator << (ostream& s, const NAME##_cus_field_list<Manip>& obj) { 
-    bool before = false; 
-$cus_field_list 
-    return s; 
-  } 
-
-  template <class Manip>
-  ostream& operator << (ostream& s, const NAME##_cus_equal_list<Manip>& obj) { 
-    bool before = false; 
-$cus_equal_list 
-    return s; 
-  } 
-
-  template <class Manip>
-  inline NAME##_value_list<Manip> NAME##::value_list(cchar *d, Manip m) const { 
-    return NAME##_value_list<Manip> (this, d, m); 
-  } 
-
-  template <class Manip>
-  inline NAME##_field_list<Manip> NAME##::field_list(cchar *d, Manip m) const { 
-    return NAME##_field_list<Manip> (this, d, m); 
-  } 
-
-  template <class Manip>
-  inline NAME##_equal_list<Manip> NAME##::equal_list(cchar *d, cchar *c, Manip m) const { 
-    return NAME##_equal_list<Manip> (this, d, c, m); 
-  } 
- 
-  template <class Manip>
-  inline NAME##_cus_value_list<Manip> NAME##::value_list(cchar *d, Manip m,
-						       $cusparms11) const {
-    return NAME##_cus_value_list<Manip> (this, d, m, $cusparmsv); 
-  } 
-
-  template <class Manip>
-  inline NAME##_cus_field_list<Manip> NAME##::field_list(cchar *d, Manip m,
-							 $cusparms11) const { 
-    return NAME##_cus_field_list<Manip> (this, d, m, $cusparmsv); 
-  } 
-
-  template <class Manip>
-  inline NAME##_cus_equal_list<Manip> NAME##::equal_list(cchar *d, cchar *c, Manip m,
-							 $cusparms11) const { 
-    return NAME##_cus_equal_list<Manip> (this, d, c, m, $cusparmsv); 
-  } 
-
-  template <class Manip>
-  inline NAME##_cus_value_list<Manip> NAME##::value_list(cchar *d, Manip m,
-						       $cusparms22) const { 
-    return NAME##_cus_value_list<Manip> (this, d, m, $cusparmsv); 
-  } 
-
-  template <class Manip>
-  inline NAME##_cus_field_list<Manip> NAME##::field_list(cchar *d, Manip m,
-							 $cusparms22) const {
-    return NAME##_cus_field_list<Manip> (this, d, m, $cusparmsv); 
-  } 
-
-  template <class Manip>
-  inline NAME##_cus_equal_list<Manip> NAME##::equal_list(cchar *d, cchar *c, Manip m, 
-							 $cusparms22) const { 
-    return NAME##_cus_equal_list<Manip> (this, d, c, m, $cusparmsv); 
-  } 
-
-  template <class Manip>
-  inline NAME##_cus_value_list<Manip> 
-  NAME##::value_list(cchar *d, Manip m, sql_cmp_type sc) const {
-    sql_compare_type_def_##CMP (NAME, value, NUM);
-  }
-
-  template <class Manip>
-  inline NAME##_cus_field_list<Manip> 
-  NAME##::field_list(cchar *d, Manip m, sql_cmp_type sc) const {
-    sql_compare_type_def_##CMP (NAME, field, NUM);
-  }
-
-  template <class Manip>
-  inline NAME##_cus_equal_list<Manip> 
-  NAME##::equal_list(cchar *d, cchar *c, Manip m, sql_cmp_type sc) const {
-    sql_compare_type_defe_##CMP (NAME, equal, NUM);
-  }
-
-  template <sql_dummy_type dummy> 
-  void populate_##NAME (NAME *s, const MysqlRow &row) { 
-$popul
-  } 
-
-  inline NAME##::##NAME (const MysqlRow &row) 
-                                        {populate_##NAME##<sql_dummy>(this, row);}
-  inline void NAME##::set (const MysqlRow &row)
-                                        {populate_##NAME##<sql_dummy>(this, row);}
-
-  sql_COMPARE__##CMP##(NAME, $parmc )
----
-print OUT &prepare($out);
-
-#
-# short cut defs
-#
-
-print OUT << "---";
-#define sql_create_basic_$i(NAME, CMP, CONTR, $parm_simple_b) \\
-  sql_create_basic_c_order_$i(NAME, CMP, CONTR, $parm_simple2c_b)
-
-#define sql_create_$i(NAME, CMP, CONTR, $parm_simple) \\
-  sql_create_complete_$i(NAME, CMP, CONTR, $parm_simple2c) \\
-
-#define sql_create_c_order_$i(NAME, CMP, CONTR, $parm_order) \\
-  sql_create_complete_$i(NAME, CMP, CONTR, $parm_order2c)
-
-#define sql_create_c_names_$i(NAME, CMP, CONTR, $parm_names) \\
-  sql_create_complete_$i(NAME, CMP, CONTR, $parm_names2c)
-
-// ---------------------------------------------------
-//                  End Create $i
-// ---------------------------------------------------
-
----
-
-}
-
-
-sub prepare {
-    local $_ = @_[0];
-    s/\n+$//;
-    s/\n[\n ]*\n/\n/g; 
-    s/\n+/\\\n/g;
-    $_ .= "\n\n";
-    return $_;
-}
-

DELETED sqlplusint/datetime.cc
Index: sqlplusint/datetime.cc
==================================================================
--- sqlplusint/datetime.cc
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "datetime3.hh"
-#include <iomanip.h>
-
-ostream& mysql_date::out_stream (ostream& s) const {
-  char fill = s.fill('0');
-#ifdef __USLC__
-  long flags = s.setf(ios::right);
-#else
-  ios::fmtflags flags = s.setf(ios::right);
-#endif
-  s << setw(4) << year << '-' 
-    << setw(2) << month << '-'
-    << setw(2) << day;
-  s.flags(flags);
-  s.fill(fill);
-  return s;
-}
-
-ostream& mysql_time::out_stream (ostream& s) const {
-  char fill = s.fill('0');
-#ifdef __USLC__
-  long flags = s.setf(ios::right);
-#else
-  ios::fmtflags flags = s.setf(ios::right);
-#endif
-  s << setw(2) << hour << ':' 
-    << setw(2) << minute << ':'
-    << setw(2) << second;
-  s.flags(flags);
-  s.fill(fill);
-  return s;
-}
-
-ostream& MysqlDateTime::out_stream (ostream& s) const {
-  mysql_date::out_stream(s);
-  s << " ";
-  mysql_time::out_stream(s);
-  return s;
-}
-
-cchar* mysql_date::convert (cchar* str) {
-  char num[5];
-  num[0] =*str++; num[1] =*str++; num[2] =*str++; num[3] =*str++; num[4] = 0;
-  year = strtol(num,0,10);
-  if (*str == '-') str++;
-  num[0] = *str++; num[1] = *str++; num[2] = 0;
-  month = strtol(num,0,10);
-  if (*str == '-') str++;
-  num[0] = *str++; num[1] = *str++; num[2] = 0;
-  day = strtol(num,0,10);
-  return str;
-}
-
-cchar* mysql_time::convert (cchar* str) {
-  char num[5];
-  num[0] = *str++; num[1] = *str++; num[2] = 0;
-  hour = strtol(num,0,10);
-  if (*str == ':') str++;
-  num[0] = *str++; num[1] = *str++; num[2] = 0;
-  minute = strtol(num,0,10);
-  if (*str == ':') str++;
-  num[0] = *str++; num[1] = *str++; num[2] = 0;
-  second = strtol(num,0,10);
-  return str;
-}
-
-cchar* MysqlDateTime::convert (cchar* str) {
-  str = mysql_date::convert(str);
-  if (*str == ' ') str++;
-  str = mysql_time::convert(str);
-  return str;
-}
-
-short int mysql_date::compare(const mysql_date* other) const {
-  if (year != other->year) return year - other->year;
-  if (month != other->month) return month - other->month;
-  return day - other->day;
-}
-
-short int mysql_time::compare(const mysql_time* other) const {
-  if (hour != other->hour) return hour - other->hour;
-  if (minute != other->minute) return minute - other->minute;
-  return minute - other->minute;
-}
-
-short int MysqlDateTime::compare(const MysqlDateTime &other) const {
-  int x;
-  x = mysql_date::compare(&other);
-  if (x) return x;
-  return mysql_time::compare(&other);
-}
-
-
-
-
-

DELETED sqlplusint/datetime1.hh
Index: sqlplusint/datetime1.hh
==================================================================
--- sqlplusint/datetime1.hh
+++ /dev/null
@@ -1,151 +0,0 @@
-#ifndef __datatime1_hh__
-
-#ifndef __datetime1_hh__
-
-// for some strange strange reason when I just use one #ifndef it
-// doesn't work.  If anyone has any idea what is going on please let
-// me know
-
-#define __datetime1_hh__
-
-#include <string>
-#include <strstream.h>
-#include <iostream.h>
-#include "defs"
-#include "define_short"
-#include "coldata1.hh"
-#include "stream2string1.hh"
-#include "tiny_int1.hh"
-
-struct mysql_dt_base {
-  virtual ostream& out_stream(ostream&) const = 0;
-
-  operator string ();
-};
-
-template <class T>
-struct MysqlDTbase {
-  virtual short int compare(const T &other) const = 0;
-
-  bool operator == (const T &other) const {return !compare(other);}
-  bool operator != (const T &other) const {return compare(other);}
-  bool operator <  (const T &other) const {return compare(other) < 0;}
-  bool operator <= (const T &other) const {return compare(other) <= 0;}
-  bool operator >  (const T &other) const {return compare(other) > 0;}
-  bool operator >= (const T &other) const {return compare(other) >= 0;}
-};
-
-struct mysql_date : virtual public mysql_dt_base {
-  short int year;
-  tiny_int  month;
-  tiny_int  day;
-
-  ostream& out_stream(ostream&) const;
-  cchar* convert (cchar*);
-protected:
-  short int compare(const mysql_date *other) const;
-};
-
-//: A special type for holding mysql Dates.
-// Date, a comparable data structures for holding mysql Dates.  It also
-// responds to the stream extraction and insertion operator.
-/*!dummy:
-  struct Date {
-    short int year;  //: The year in 4 digit form
-    tiny_int  month; //: The month number
-    tiny_int  day;   //: The day of the month
-
-    Date ();                    //:
-    Date (cchar* str);          //:
-    Date (const ColData &str);  //:
-    Date (const string &str);   //:
-
-    short int compare(const Date& other) const;
-    //: Compare two dates
-    // Returns 0 if *this == other, <0 if *this < *other, >0 if *this > other
-  };
-*/
-
-struct Date : public mysql_date, public MysqlDTbase<Date>
-{
-  Date () {};
-  Date (cchar* str) {convert(str);}
-  Date (const ColData &str);
-  Date (const string &str);
-
-  short int compare(const Date& other) const 
-    {return mysql_date::compare(&other);}
-};
-
-inline ostream& operator << (ostream& s, const Date& d) 
-                                                  {return d.out_stream(s);}
-
-struct mysql_time : virtual public mysql_dt_base {
-  tiny_int hour;
-  tiny_int minute;  
-  tiny_int second;
-
-  ostream& out_stream(ostream&) const;
-  cchar* convert (cchar*);
-protected:
-  short int compare(const mysql_time *other) const;
-};  
-
-//: A special type for holding mysql Dates.
-// Time, a comparable data structures for holding mysql Times.  It also
-// responds to the stream extraction and insertion operator.
-/*!dummy:
-  struct Time {
-    tiny_int hour;   //: Hour in military time
-    tiny_int minute; //:
-    tiny_int second; //:
-
-    Time () {};                //:
-    Time (cchar* str);         //:
-    Time (const ColData &str); //:
-    Time (const string &str);  //:
-
-    short int compare(const Time& other) const;
-    //: Compare two times
-    // Returns 0 if *this == other, <0 if *this < *other, >0 if *this > other
-  };
-*/
-
-struct Time : public mysql_time, public MysqlDTbase<Time>
-{
-  Time () {};
-  Time (cchar* str) {convert(str);}
-  Time (const ColData &str);
-  Time (const string &str);
-
-  short int compare(const Time& other) const 
-    {return mysql_time::compare(&other);}
-};
-
-
-inline ostream& operator << (ostream& s, const Time& d)
-                                                 {return d.out_stream(s);}
-
-//: A combinate of Date and Time for holding mysql DateTime's
-//!dummy: struct DateTime {};
-
-struct DateTime : public mysql_date, public mysql_time,
-		       public MysqlDTbase<DateTime>
-{
-  DateTime () {}
-  DateTime (cchar* str) {convert(str);}
-  DateTime (const ColData &str);
-  DateTime (const string &str);
-
-  short int compare(const DateTime& other) const;
-
-  ostream& out_stream(ostream&) const;
-  cchar* convert (cchar*);
-};
-
-inline ostream& operator << (ostream& s, const DateTime& d)
-                                                   {return d.out_stream(s);}
-
-#endif
-#endif //__datetime1_hh__
-

DELETED sqlplusint/datetime2.hh
Index: sqlplusint/datetime2.hh
==================================================================
--- sqlplusint/datetime2.hh
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef __datetime2_hh__
-#define __datetime2_hh__
-
-#include "datetime1.hh"
-#include "coldata2.hh"
-#include "stream2string2.hh"
-
-inline mysql_dt_base::operator string () {
-  return stream2string<string>(*this);
-}
-
-inline Date::Date (const ColData &str) {convert(str.c_str());}
-inline Date::Date (const string &str)  {convert(str.c_str());}
-
-inline Time::Time (const ColData &str) {convert(str.c_str());}
-inline Time::Time (const string &str)  {convert(str.c_str());}
-
-inline DateTime::DateTime (const ColData &str) {convert(str.c_str());}
-inline DateTime::DateTime (const string &str) {convert(str.c_str());}
-
-#endif

DELETED sqlplusint/datetime3.hh
Index: sqlplusint/datetime3.hh
==================================================================
--- sqlplusint/datetime3.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "datetime2.hh"
-

DELETED sqlplusint/define_short
Index: sqlplusint/define_short
==================================================================
--- sqlplusint/define_short
+++ /dev/null
@@ -1,64 +0,0 @@
-
-// defs.h
-
-#ifndef __define_short_h__
-#define __define_short_h__
-
-#define use_exceptions mysql_use_exceptions
-
-// base.h           
-#define BadQuery    MysqlBadQuery
-#define MysqlCon    MysqlConnection
-#define Connection  MysqlConnection
-
-// result.h
-#define ResNSel     MysqlResNSel
-#define ResUse      MysqlResUse
-#define Result      MysqlRes
-#define Field       MysqlField
-#define Fields      MysqlFields
-
-// resiter.h
-#define ResIter     MysqlResIter
-#define ResultIter  MysqlResIter
-
-// row.h
-#define Row          MysqlRow
-#define MutableRow   MysqlMutableRow
-
-// field_names.h
-#define FieldNames  MysqlFieldNames
-
-//query.h
-#define Query       MysqlQuery
-
-//string.h
-#define BadConversion  MysqlBadConversion
-#define ColData        MysqlColData
-#define MutableColData MysqlMutableColData
-
-// manip.h
-#define quote              mysql_quote
-#define quote_only         mysql_quote_only
-#define quote_double_only  mysql_quote_double_only
-#define escape             mysql_escape
-#define do_nothing         mysql_do_nothing
-#define ignore             mysql_ignore
-
-// datetime.h
-#define Date        MysqlDate
-#define Time        MysqlTime
-#define DateTime    MysqlDateTime
-
-// set.h
-#define Set         MysqlSet
-
-// null.h
-#define Null        MysqlNull
-#define null_type   mysql_null_type
-#define null        mysql_null
-#define NullisNull  MysqlNullisNull
-#define NullisZero  MysqlNullisZero
-#define NullisBlank MysqlNullisBlank
-
-#endif

DELETED sqlplusint/defs
Index: sqlplusint/defs
==================================================================
--- sqlplusint/defs
+++ /dev/null
@@ -1,20 +0,0 @@
-
-#ifndef __mysql_defs_h_
-#define __mysql_defs_h_
-
-#include <mysql.h>
-#include "define_short"
-
-typedef MYSQL_FIELD MysqlField;
-typedef const char cchar;
-typedef long long int longgint;
-
-class Connection;
-class ResUse;
-class Result;
-class FieldNames;
-
-const bool use_exceptions = true;
-
-#endif
-

DELETED sqlplusint/field_names.cc
Index: sqlplusint/field_names.cc
==================================================================
--- sqlplusint/field_names.cc
+++ /dev/null
@@ -1,12 +0,0 @@
-
-#include "field_names3.hh"
-#include "result2.hh"
-
-void FieldNames::init(const ResUse *res) {
-  int num = res->num_fields();
-  reserve(num);
-  for (int i = 0; i < num; i++) {
-    push_back(res->fields()[i].name);
-  }
-}
-

DELETED sqlplusint/field_names1.hh
Index: sqlplusint/field_names1.hh
==================================================================
--- sqlplusint/field_names1.hh
+++ /dev/null
@@ -1,38 +0,0 @@
-
-#ifndef __field_names1_hh__
-#define __field_names1_hh__
-
-#include <vector.h>
-#include <algo.h>
-#include "defs"
-#include "define_short"
-#include "coldata1.hh"
-
-//: A vector of the field names.
-class FieldNames : public vector<string> {
-private:
-  void init (const ResUse *res);
-public:
-  FieldNames () {}
-  FieldNames (const ResUse *res) {init(res);}
-  FieldNames (int i) : vector<string>(i) {}
-
-  FieldNames& operator = (const ResUse *res) {init(res); return *this;}  
-  //: Creates a new list from the data in res.
-  FieldNames& operator = (int i) {insert(begin(), i, ""); return *this;} 
-  //: Creates a new list with i field names.
-  
-  string&  operator [] (int i) {return vector<string>::operator [] (i);}
-  //: returns the field name of the field with that index number
-
-  const string&  operator [] (int i) const 
-    {return vector<string>::operator [] (i);}
-  //: returns the field name of the field with that index number
-
-  uint     operator [] (string i) const
-    {return find(begin(),end(), i) - begin();}
-  //: returns the index number of the field with that name
-};
-
-#endif
-

DELETED sqlplusint/field_names2.hh
Index: sqlplusint/field_names2.hh
==================================================================
--- sqlplusint/field_names2.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "field_names1.hh"

DELETED sqlplusint/field_names3.hh
Index: sqlplusint/field_names3.hh
==================================================================
--- sqlplusint/field_names3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "field_names2.hh"

DELETED sqlplusint/field_types.cc
Index: sqlplusint/field_types.cc
==================================================================
--- sqlplusint/field_types.cc
+++ /dev/null
@@ -1,12 +0,0 @@
-
-#include "field_types3.hh"
-#include "result2.hh"
-
-void FieldTypes::init(const ResUse *res) {
-  int num = res->num_fields();
-  reserve(num);
-  for (int i = 0; i < num; i++) {
-    push_back(res->fields(i));
-  }
-}
-

DELETED sqlplusint/field_types1.hh
Index: sqlplusint/field_types1.hh
==================================================================
--- sqlplusint/field_types1.hh
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef __field_types1_hh__
-#define __field_types1_hh__
-
-#include <vector.h>
-#include "defs"
-#include "define_short"
-#include "type_info1.hh"
-
-//: A vector of the field types.
-class FieldTypes : public vector<mysql_type_info> {
-private:
-  void init (const ResUse *res);
-public:
-  FieldTypes () {}
-  FieldTypes (const ResUse *res) {init(res);}
-  FieldTypes (int i) : vector<mysql_type_info>(i) {}
-
-  FieldTypes& operator = (const ResUse *res) {init(res); return *this;}
-  //: Creates a new list based on the info in res
-  FieldTypes& operator = (int i) {insert(begin(), i, 
-					 mysql_type_info()); return *this;}
-  //: Creates a new list with i fields. 
-  
-  mysql_type_info&  operator [] (int i) {return vector<mysql_type_info>
-				  ::operator [] (i);}
-  //: Returns the field type for the field with an offset of i.
-  const mysql_type_info&  operator [] (int i) const 
-    {return vector<mysql_type_info>::operator[] (i);}
-  //: Returns the field type for the field with an offset of i.
-};
-
-#endif
-
-
-
-
-

DELETED sqlplusint/field_types2.hh
Index: sqlplusint/field_types2.hh
==================================================================
--- sqlplusint/field_types2.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "field_types1.hh"

DELETED sqlplusint/field_types3.hh
Index: sqlplusint/field_types3.hh
==================================================================
--- sqlplusint/field_types3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "field_types2.hh"

DELETED sqlplusint/fields1.hh
Index: sqlplusint/fields1.hh
==================================================================
--- sqlplusint/fields1.hh
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef __fields1_hh__
-#define __fields1_hh__
-
-#include "resiter1.hh"
-
-class ResUse;
-
-//: A vector like container with the raw mysql field info.
-class Fields : public const_subscript_container<Fields, Field>
-{
-private:
-  mutable ResUse *res;
-public:
-  Fields() {}
-  Fields(ResUse *r) : res(r) {}
-  size_type size() const; //: the number of fields.
-  //: Returns the field with an offset of i;
-  const Field& operator [] (size_type i) const;
-  const Field& operator [] (int i) const {return operator [](size_type(i));} 
-};
-
-#endif
-

DELETED sqlplusint/fields2.hh
Index: sqlplusint/fields2.hh
==================================================================
--- sqlplusint/fields2.hh
+++ /dev/null
@@ -1,12 +0,0 @@
-
-#ifndef __fields2_hh__
-#define __fields2_hh__
-
-inline Fields::size_type Fields::size() const {return res->num_fields();}
-
-inline const Field& Fields::operator [] (Fields::size_type i) const {
-    res->field_seek(i); 
-    return res->fetch_field();
-}
-
-#endif

DELETED sqlplusint/magic.h
Index: sqlplusint/magic.h
==================================================================
--- sqlplusint/magic.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#define virtual_def (oper) \
-  virtual operator oper () const = 0; \
-  virtual holder* create(const &oper) = 0
-
-#define virtual_int_def (oper) \
-  virtual_def (oper); \
-  vortual_def (unsigned oper)
-
-
-class MagicType {
-  class holder_base {
-  public:
-    virtual_int_def (char);
-    virtual_int_def (short int);
-    virtual_int_def (long ing);
-    virtual_int_def (long long int);
-    virtual_def (float);
-    virtual_def (double);
-    virtual_def (string);
-  }
-  template <class Type, const char* Name, tiny_int Id, unsigned short int Id2,
-            unsigned short int Mask>
-  class holder : public holder_base {
-  public:
-    Type value;
-    static const name = Name;
-    static const tiny_int id = Id;
-    static const unsigned short int id2 = Id2;
-    static const unsigned short int mask = Mask;
-  }
-
-    
-  
-      
-    

DELETED sqlplusint/manip.cc
Index: sqlplusint/manip.cc
==================================================================
--- sqlplusint/manip.cc
+++ /dev/null
@@ -1,209 +0,0 @@
-
-#include "manip3.hh"
-
-// quote manipulator
-
-SQLQueryParms& operator << (quote_type2 p, SQLString &in) {
-  if (in.is_string) {
-    if (in.dont_escape) {
-      SQLString in2 = "'" + in + "'";
-      in2.processed = true;
-      return *p.qparms << in2;
-    } else {
-      char* s = new char[in.size()*2+1];
-      mysql_escape_string(s, const_cast<char *>(in.c_str()), in.size() );
-      SQLString in2 = SQLString("'") + s + "'";
-      in2.processed = true;
-      *p.qparms << in2;
-      delete s;
-      return *p.qparms;
-    }
-  } else {
-    in.processed = true;
-    return *p.qparms << in;
-  }
-}
-
-template <>
-ostream& operator << (quote_type1 o, const string &in) {
-  char* s = new char[in.size()*2+1];
-  mysql_escape_string(s, const_cast<char *>(in.c_str()), in.size() );
-  *o.ostr << "'" << s << "'";
-  delete s;
-  return *o.ostr;
-}
-
-template <>
-ostream& operator << (quote_type1 o, const char* const &in) {
-  unsigned int size;
-  for (size=0; in[size]; size++);
-  char* s = new char[size*2];
-  mysql_escape_string(s, const_cast<char *>(in), size);
-  *o.ostr << "'" << s << "'";
-  delete s; 
-  return *o.ostr;
-}
-
-template <class Str>
-inline ostream& _manip (quote_type1 o, const mysql_ColData<Str>& in) {
-  if (in.escape_q()) {
-    char *s = new char[in.size()*2+1];
-    mysql_escape_string(s, const_cast<char *>(in.c_str()), in.size() );
-    if (in.quote_q())
-      *o.ostr << "'" << s << "'";
-    else
-      *o.ostr << s;
-    delete s;
-  } else if (in.quote_q()) {
-    *o.ostr << "'" << in << "'";
-  } else {
-    *o.ostr << in;
-  }
-  return *o.ostr;
-}
-
-template <>
-ostream& operator << (quote_type1 o, const mysql_ColData<string>& in) {
-  return _manip(o,in);
-}
-
-template <>
-ostream& operator << (quote_type1 o, const mysql_ColData<const_string>& in) {
-  return _manip(o,in);
-}
-
-// quote only manipulator
-
-SQLQueryParms & operator << (quote_only_type2 p, SQLString &in) {
-  if (in.is_string) {
-    SQLString in2 = "'" + in + "'";
-    in2.processed = true;
-    return *p.qparms << in2;
-  } else {
-    in.processed = true;
-    return *p.qparms << in;
-  }
-}
-
-template <>
-ostream& operator << (quote_only_type1 o, const mysql_ColData<string>& in) {
-  if (in.quote_q()) {
-    *o.ostr << "'" << in << "'";
-  } else {
-    *o.ostr << in;
-  }
-  return *o.ostr;
-}
-
-template <>
-ostream& operator << (quote_only_type1 o, const mysql_ColData<const_string>& in) {
-  if (in.quote_q()) {
-    *o.ostr << "'" << in << "'";
-  } else {
-    *o.ostr << in;
-  }
-  return *o.ostr;
-}
-
-// quote double only manipulator
-
-SQLQueryParms & operator << (quote_double_only_type2 p, SQLString &in) {
-  if (in.is_string) {
-    SQLString in2 = "\"" + in + "\"";
-    in2.processed = true;
-    return *p.qparms << in2;
-  } else {
-    in.processed = true;
-    return *p.qparms << in;
-  }
-}
-
-
-template <>
-ostream& operator << (quote_double_only_type1 o, const mysql_ColData<string>& in) {
-  if (in.quote_q()) {
-    *o.ostr << "'" << in << "'";
-  } else {
-    *o.ostr << in;
-  }
-  return *o.ostr;
-}
-
-template <>
-ostream& operator << (quote_double_only_type1 o, const mysql_ColData<const_string>& in) {
-  if (in.quote_q()) {
-    *o.ostr << "'" << in << "'";
-  } else {
-    *o.ostr << in;
-  }
-  return *o.ostr;
-}
-
-// escape manipulator
-
-SQLQueryParms & operator << (escape_type2 p, SQLString &in) {
-  if (in.is_string) {
-    if (in.dont_escape) {
-      in.processed = true;
-      return *p.qparms << in;
-    } else {
-      char* s = new char[in.size()*2+1];
-      mysql_escape_string(s, const_cast<char *>(in.c_str()), in.size() );
-      SQLString in2 = s;
-      in2.processed = true;
-      *p.qparms << in2;
-      delete s;
-      return *p.qparms;
-    }
-  } else {
-    in.processed = true;
-    return *p.qparms << in;
-  }
-}
-
-template <>
-ostream& operator << (escape_type1 o, const string &in) {
-  char* s = new char[in.size()*2+1];
-  mysql_escape_string(s, const_cast<char *>(in.c_str()), in.size());
-  *o.ostr << s;
-  delete s;
-  return *o.ostr;
-}
-
-template <>
-ostream& operator << (escape_type1 o, const char* const &in) {
-  unsigned int size;
-  for (size=0; in[size]; size++);
-  char* s = new char[size*2];
-  mysql_escape_string(s, const_cast<char *>(in), size);
-  *o.ostr << s;
-  delete s; 
-  return *o.ostr;
-}
-
-
-template <class Str>
-inline ostream& _manip (escape_type1 o, const mysql_ColData<Str>& in) {
-  if (in.escape_q()) {
-    char *s = new char[in.size()*2+1];
-    mysql_escape_string(s, const_cast<char *>(in.c_str()), in.size() );
-    delete s;
-  } else {
-    *o.ostr << in;
-  }
-  return *o.ostr;
-}
-
-template <>
-ostream& operator << (escape_type1 o, const mysql_ColData<string>& in) {
-  return _manip(o,in);
-}
-
-template <>
-ostream& operator << (escape_type1 o, const mysql_ColData<const_string>& in) {
-  return _manip(o,in);
-}
-
-
-
-

DELETED sqlplusint/manip1.hh
Index: sqlplusint/manip1.hh
==================================================================
--- sqlplusint/manip1.hh
+++ /dev/null
@@ -1,306 +0,0 @@
-#ifndef __manip1_hh__
-#define __manip1_hh__
-#ifdef __WIN32__
-#include <Windows32/Base.h>
-#include <Windows32/Defines.h>
-#include <Windows32/Structures.h>
-#include <winsock.h>
-#define errno WSAGetLastError()
-#endif
-#include <mysql.h>
-#include <iostream>
-#include "define_short"
-#include "sql_string1.hh"
-#include "sql_query1.hh"
-#include "datetime1.hh"
-#include "set1.hh"
-
-//quote manipulaor
-
-class SQLQueryParms;
-
-enum quote_type0 {mysql_quote};
-
-struct quote_type1 {
-  ostream *ostr;
-  quote_type1(ostream *o) : ostr(o) {}
-}; 
-
-inline quote_type1 operator << (ostream &o, quote_type0 esc) {
-  return quote_type1(&o);
-}
-
-struct quote_type2 {
-  SQLQueryParms *qparms;
-  quote_type2(SQLQueryParms *p) : qparms(p) {}
-};
-
-inline quote_type2 operator << (SQLQueryParms &p, quote_type0 esc) {
-  return quote_type2(&p);
-}
-
-SQLQueryParms& operator << (quote_type2 p, SQLString &in);
-
-template <class T>
-inline ostream& operator << (quote_type1 o, const T &in) {
-  return *o.ostr << in;
-}
-
-template <>
-ostream& operator << (quote_type1 o, const string &in);
-
-template <>
-ostream& operator << (quote_type1 o, const char* const &in);
-
-template <>
-ostream& operator << (quote_type1 o, const mysql_ColData<string>& in);
-
-template <>
-ostream& operator << (quote_type1 o, const mysql_ColData<const_string>& in);
-
-template <>
-inline ostream& operator << (quote_type1 o, char* const &in) {
-  return operator << (o, const_cast<const char* const &>(in));
-}
-
-template <>
-inline ostream& operator << (quote_type1 o, const Date &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-template <>
-inline ostream& operator << (quote_type1 o, const Time &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-template <>
-inline ostream& operator << (quote_type1 o, const DateTime &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-template <class ST>
-inline ostream& operator << (quote_type1 o, const MysqlSet<ST> &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-// quote only manipulator
-
-enum quote_only_type0 {mysql_quote_only};
-
-struct quote_only_type1 {
-  ostream *ostr;
-  quote_only_type1(ostream *o) : ostr(o) {}
-}; 
-
-inline quote_only_type1 operator << (ostream &o, quote_only_type0 esc) {
-  return quote_only_type1(&o);
-}
-
-struct quote_only_type2 {
-  SQLQueryParms *qparms;
-  quote_only_type2(SQLQueryParms *p) : qparms(p) {}
-};
-
-inline quote_only_type2 operator << (SQLQueryParms &p, quote_only_type0 esc) {
-  return quote_only_type2(&p);
-}
-
-SQLQueryParms & operator << (quote_only_type2 p, SQLString &in);
-
-template <class T>
-inline ostream& operator << (quote_only_type1 o, const T &in) {
-  return *o.ostr << in;
-}
-
-template <>
-inline ostream& operator << (quote_only_type1 o, const string &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-template <>
-ostream& operator << (quote_only_type1 o, const mysql_ColData<string>& in);
-
-template <>
-ostream& operator << (quote_only_type1 o, const mysql_ColData<const_string>& in);
-
-template <>
-inline ostream& operator << (quote_only_type1 o, const Date &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-template <>
-inline ostream& operator << (quote_only_type1 o, const Time &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-template <>
-inline ostream& operator << (quote_only_type1 o, const DateTime &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-template <class ST>
-inline ostream& operator << (quote_only_type1 o, const MysqlSet<ST> &in) {
-  return *o.ostr << "'" << in << "'";
-}
-
-// quote double (") only manipulator
-
-enum quote_double_only_type0 {mysql_quote_double_only};
-struct quote_double_only_type1 {
-  ostream *ostr;
-  quote_double_only_type1(ostream *o) : ostr(o) {}
-}; 
-
-inline quote_double_only_type1 operator << (ostream &o, 
-					    quote_double_only_type0 esc) {
-  return quote_double_only_type1(&o);
-}
-
-struct quote_double_only_type2 {
-  SQLQueryParms *qparms;
-  quote_double_only_type2(SQLQueryParms *p) : qparms(p) {}
-};
-
-inline quote_double_only_type2 operator << (SQLQueryParms &p, 
-					     quote_double_only_type0 esc) {
-  return quote_double_only_type2(&p);
-}
-
-SQLQueryParms & operator << (quote_double_only_type2 p, SQLString &in);
-
-template <class T>
-inline ostream& operator << (quote_double_only_type1 o, const T &in) {
-  return *o.ostr << in;
-}
-
-template <>
-inline ostream& operator << (quote_double_only_type1 o, const string &in) {
-  return *o.ostr << "\"" << in << "\"";
-}
-
-template <>
-ostream& operator << (quote_double_only_type1 o, const mysql_ColData<string>& in);
-
-template <>
-ostream& operator << (quote_double_only_type1 o, const mysql_ColData<const_string>& in);
-
-template <>
-inline ostream& operator << (quote_double_only_type1 o, const Date &in) {
-  return *o.ostr << "\"" << in << "\"";
-}
-
-template <>
-inline ostream& operator << (quote_double_only_type1 o, const Time &in) {
-  return *o.ostr << "\"" << in << "\"";
-}
-
-template <>
-inline ostream& operator << (quote_double_only_type1 o, 
-			     const DateTime &in) {
-  return *o.ostr << "\"" << in << "\"";
-}
-
-template <class ST>
-inline ostream& operator << (quote_double_only_type1 o, 
-			     const MysqlSet<ST> &in) {
-  return *o.ostr << "\"" << in << "\"";
-}
-
-// escape manipulator
-
-enum escape_type0 {mysql_escape};
-struct escape_type1 {
-  ostream *ostr;
-  escape_type1(ostream *o) : ostr(o) {}
-}; 
-
-inline escape_type1 operator << (ostream &o, escape_type0 esc) {
-  return escape_type1(&o);
-}
-
-struct escape_type2 {
-  SQLQueryParms *qparms;
-  escape_type2(SQLQueryParms *p) : qparms(p) {}
-};
-
-inline escape_type2 operator << (SQLQueryParms &p, escape_type0 esc) {
-  return escape_type2(&p);
-}
-
-SQLQueryParms & operator << (escape_type2 p, SQLString &in);
-
-template <class T>
-inline ostream& operator << (escape_type1 o, const T &in) {
-  return *o.ostr << in;
-}
-
-template <>
-ostream& operator << (escape_type1 o, const string &in);
-
-template <>
-ostream& operator << (escape_type1 o, const char* const &in);
-
-template <>
-ostream& operator << (escape_type1 o, const mysql_ColData<string>& in);
-
-template <>
-ostream& operator << (escape_type1 o, const mysql_ColData<const_string>& in);
-
-template <>
-inline ostream& operator << (escape_type1 o, char* const &in) {
-  return operator << (o, const_cast<const char* const &>(in));
-}
-
-
-//do nothing manipulator
-
-enum do_nothing_type0 {mysql_do_nothing};
-struct do_nothing_type1 {
-  ostream *ostr;
-  do_nothing_type1(ostream *o) : ostr(o) {}
-}; 
-
-inline do_nothing_type1 operator << (ostream &o, do_nothing_type0 esc) {
-  return do_nothing_type1(&o);
-}
-
-template <class T>
-inline ostream& operator << (do_nothing_type1 o, const T &in) {
-  return *o.ostr << in;
-}
-
-struct do_nothing_type2 {
-  SQLQueryParms *qparms;
-  do_nothing_type2(SQLQueryParms *p) : qparms(p) {}
-};
-
-inline do_nothing_type2 operator << (SQLQueryParms &p, do_nothing_type0 esc) {
-  return do_nothing_type2(&p);
-}
-
-inline SQLQueryParms & operator << (do_nothing_type2 p, SQLString &in) {
-  in.processed = true;
-  return *p.qparms << in;
-}
-
-enum ignore_type0 {mysql_ignore};
-
-struct ignore_type2 {
-  SQLQueryParms *qparms;
-  ignore_type2(SQLQueryParms *p) : qparms(p) {}
-};
-
-inline ignore_type2 operator << (SQLQueryParms &p, ignore_type0 esc) {
-  return ignore_type2(&p);
-}
-
-inline SQLQueryParms & operator << (ignore_type2 p, SQLString &in) {
-  return *p.qparms << in;
-}
-
-#endif
-
-
-
-
-

DELETED sqlplusint/manip2.hh
Index: sqlplusint/manip2.hh
==================================================================
--- sqlplusint/manip2.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "manip1.hh"

DELETED sqlplusint/manip3.hh
Index: sqlplusint/manip3.hh
==================================================================
--- sqlplusint/manip3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "manip2.hh"

DELETED sqlplusint/mysql++
Index: sqlplusint/mysql++
==================================================================
--- sqlplusint/mysql++
+++ /dev/null
@@ -1,73 +0,0 @@
-
-#include "defs"
-#include "define_short"
-
-#include "coldata1.hh"
-#include "compare1.hh"
-#include "connection1.hh"
-#include "const_string1.hh"
-#include "convert1.hh"
-#include "datetime1.hh"
-#include "field_names1.hh"
-#include "field_types1.hh"
-#include "fields1.hh"
-#include "manip1.hh"
-#include "null1.hh"
-#include "query1.hh"
-#include "resiter1.hh"
-#include "result1.hh"
-#include "row1.hh"
-#include "set1.hh"
-#include "sql_query1.hh"
-#include "sql_string1.hh"
-#include "stream2string1.hh"
-#include "tiny_int1.hh"
-#include "type_info1.hh"
-#include "vallist1.hh"
-
-#include "coldata2.hh"
-#include "compare2.hh"
-#include "connection2.hh"
-#include "const_string2.hh"
-#include "convert2.hh"
-#include "datetime2.hh"
-#include "field_names2.hh"
-#include "field_types2.hh"
-#include "fields2.hh"
-#include "manip2.hh"
-#include "null2.hh"
-#include "query2.hh"
-#include "result2.hh"
-#include "row2.hh"
-#include "set2.hh"
-#include "sql_query2.hh"
-#include "sql_string2.hh"
-#include "stream2string2.hh"
-#include "tiny_int2.hh"
-#include "type_info2.hh"
-#include "vallist2.hh"
-
-#include "coldata3.hh"
-#include "compare3.hh"
-#include "connection3.hh"
-#include "const_string3.hh"
-#include "convert3.hh"
-#include "datetime3.hh"
-#include "field_names3.hh"
-#include "field_types3.hh"
-#include "manip3.hh"
-#include "null3.hh"
-#include "query3.hh"
-#include "result3.hh"
-#include "row3.hh"
-#include "set3.hh"
-#include "sql_query3.hh"
-#include "sql_string3.hh"
-#include "stream2string3.hh"
-#include "tiny_int3.hh"
-#include "type_info3.hh"
-#include "vallist3.hh"
-
-#ifdef MYSQL_NO_SHORT_NAMES
-#include "undef_short"
-#endif

DELETED sqlplusint/null1.hh
Index: sqlplusint/null1.hh
==================================================================
--- sqlplusint/null1.hh
+++ /dev/null
@@ -1,81 +0,0 @@
-#ifndef __null1_hh__
-#define __null1_hh__
-
-#include <ostream.h>
-#include "define_short"
-
-//! with_class = Null
-
-//: Thrown when a *Null* value is trying to be converted into a type 
-//: it can't convert to.
-class BadNullConversion {};
-
-class null_type {
-public:
-  template <class Type> operator Type () {throw BadNullConversion();}
-};
-
-//: 
-const null_type null = null_type();
-
-//: Type to use for the behavior parameter for *Null<>*
-struct NullisNull {
-  static null_type null_is() {return null_type();}
-  static ostream&  null_ostr(ostream& o) {o << "(NULL)"; return o;}
-};
-
-//: Type to use for the behavior parameter for *Null<>*
-struct NullisZero {
-  static int   null_is() {return 0;}
-  static ostream& null_ostr(ostream &o) {o << 0; return o;}
-};
-
-//: Type to use for the behavior parameter for *Null<>*
-struct NullisBlank {
-  static const char * null_is() {return "";}
-  static ostream& null_ostr(ostream &o) {o << ""; return o;}
-};
-
-//: Container class for holding null types.
-template <class Type, class Behavior = NullisNull>
-class Null {
-public:
-  Type data;
-  bool is_null;
-  typedef Type value_type;
-public:
-  Null () {} //:
-  Null (Type x) : data(x), is_null(false) {} 
-  //: 
-  Null (const null_type &n) : is_null(true) {} 
-  //: Gives Null the null value
-  // Note: the global const *null* (not NULL) is of value null_type thus 
-  // you can say something like *Null<Type> x = null*.
-  operator Type& () { 
-    if (is_null) return data = Behavior::null_is();
-    else return data; } 
-  //:
-  Null& operator = (const Type &x) {data = x; is_null = false; return *this;}
-  //: 
-  Null& operator = (const null_type &n) {is_null = true; return *this;}
-  //:
-};
-
-//: OEP - Specialization for <void>
-template <> class Null<void> {
-public:
-  bool is_null;
-  typedef void value_type;
-public:
-  Null () : is_null(false) {} 
-  //: 
-  Null (const null_type &n) : is_null(true) {} 
-  //: Gives Null the null value
-  // Note: the global const *null* (not NULL) is of value null_type thus 
-  // you can say something like *Null<Type> x = null*.
-  //:
-  Null& operator = (const null_type &n) {is_null = true; return *this;}
-  //:
-};
- 
-#endif

DELETED sqlplusint/null2.hh
Index: sqlplusint/null2.hh
==================================================================
--- sqlplusint/null2.hh
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef __null2_hh__
-#define __null2_hh__
-
-#include "null1.hh"
-
-template <class Type, class Behavior>
-inline ostream& operator << (ostream &o, const Null<Type,Behavior> &n) {
-  if (n.is_null) return Behavior::null_ostr(o);
-  else return o << n.data;
-}
-
-#endif

DELETED sqlplusint/null3.hh
Index: sqlplusint/null3.hh
==================================================================
--- sqlplusint/null3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "null2.hh"

DELETED sqlplusint/query.cc
Index: sqlplusint/query.cc
==================================================================
--- sqlplusint/query.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-
-#include "query3.hh"
-
-MysqlQuery::MysqlQuery(const MysqlQuery &q) : SQLQuery(q) {
-  throw_exceptions = q.throw_exceptions;
-  mysql = q.mysql;
-}
-
-MysqlQuery& MysqlQuery::operator = (const MysqlQuery &q) {
-  throw_exceptions = q.throw_exceptions;
-  mysql = q.mysql;
-  SQLQuery::operator = (q);
-  return *this;
-}
-
-
-
-
-
-
-

DELETED sqlplusint/query1.hh
Index: sqlplusint/query1.hh
==================================================================
--- sqlplusint/query1.hh
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef __query1_hh__
-#define __query1_hh__
-#ifdef __WIN32__
-#include <Windows32/Base.h>
-#include <Windows32/Defines.h>
-#include <Windows32/Structures.h>
-#include <winsock.h>
-#define errno WSAGetLastError()
-#endif
-#include <mysql.h>
-#include "define_short"
-#include "sql_query1.hh"
-#include "result1.hh"
-#include "connection1.hh"
-
-
-//: A Query class suitable for executing queries.  
-// This is the class is subclassed from SQLQuery. This class unlike
-// SQLQuery is loosely attached to a Mysql object so that it can
-// execute queries.
-class Query : public SQLQuery {
-private:
-  Connection   *mysql;
-  bool         throw_exceptions;
-
-  int     affected_rows() const;
-  int     insert_id ();
-  string  info ();
-  bool    lock();
-  void    unlock();
-
-public:
-  Query(Connection *m, bool te = false) 
-    {mysql = m;errmsg=NULL;Success = true;throw_exceptions=te;} 
-  //: Create a new query object attached to a connection.
-  Query(const Query &q); //:
-  Query& operator = (const Query &q); //:
-
-  string   error ();  //: The error message if the query was not successful.
-  bool     success(); //: Displays the string currently in the buffer.
-  // Same thing as string().
-
-  string   preview () {return str(def);}       //:
-  string   preview (parms &p) {return str(p);} //:
-
-  //!dummy: MysqlResNSel execute (...);
-  //: Executes the query in the string buffer.
-  // Executes the query in the string buffer and returns a structure
-  // that contains the information of the success of the query. Use
-  // this for queries that don't return a result set such as INSERT,
-  // UPDATE, etc.
-  //
-  // The parameters can be anything in a valid SQLQuery::str.
-
-  //!dummy: MysqlRes store (...);
-  //: Executes the query in the string buffer.
-  // Executes a query in the string buffer and returns the result.
-  //
-  // The parameters can be anything in a valid SQLQuery::str.
-
-  //!dummy: MysqlResUse use (...); 
-  //: Executes the query in the string buffer.
-  // Executes the query in the string buffer and returns the
-  // results. This method used the mysql_use_result(MYSQL_RES)
-  // function and thus should be used sparingly. Also the Result set is
-  // a lot more limited and DOES NOT have an iterator.
-  //
-  // The parameters can be anything in a valid SQLQuery::str.
-
-  mysql_query_define0(string,preview)
-
-  mysql_query_define1(ResNSel, execute)
-  mysql_query_define1(ResUse, use)
-  mysql_query_define1(Result, store) 
-
-  mysql_query_define2(storein_sequence)
-  mysql_query_define2(storein_set)
-
-  mysql_query_define2(storein)
-
-  template <class T> Query& update(const T &o, const T &n) {
-    SQLQuery::update(o,n);
-    return *this;
-  }
-  
-  template <class T> Query& insert(const T &v) {
-    SQLQuery::insert(v);
-    return *this;
-  }
-
-  template <class T> Query& replace(const T &v) {
-    SQLQuery::replace(v);
-    return *this;
-  }
-};
-
-#endif
-
-
-
-
-

DELETED sqlplusint/query2.hh
Index: sqlplusint/query2.hh
==================================================================
--- sqlplusint/query2.hh
+++ /dev/null
@@ -1,94 +0,0 @@
-
-#ifndef __query2_hh__
-#define __query2_hh__
-
-#include "query1.hh"
-#include "connection2.hh"
-#include "coldata2.hh"
-
-inline bool Query::success() {
-  if (!Success) return false;
-  return mysql->success();
-}
-
-inline ResNSel Query::execute(const char* str) {
-  return mysql->execute(str);
-}
-
-inline ResNSel Query::execute(parms &p, query_reset r)
-{
-  return mysql->execute(str(p,r));
-}
-
-inline ResUse Query::use(const char* str) {
-  return mysql->use(str);
-}
-
-inline ResUse Query::use(parms &p, query_reset r) {
-  return mysql->use(str(p,r));
-}
-
-inline Result Query::store(const char* str) {
-  return mysql->store(str);
-}
-
-inline Result Query::store(parms &p, query_reset r) {
-  return mysql->store(str(p,r));
-}
-
-inline int Query::affected_rows() const {
-  return mysql->affected_rows();
-}
-
-inline int Query::insert_id () {
-  return mysql->insert_id();
-}
-
-inline string Query::info() {
-  return mysql->info();
-}
-
-inline string Query::error () {
-  if (errmsg) return string(errmsg);
-  return mysql->error();
-}
-
-inline void Query::unlock() {
-  mysql->unlock();
-}
-
-template <class Seq>
-inline void Query::storein_sequence (Seq &seq,parms &p, query_reset r) {
-  mysql->storein_sequence (seq, str(p,r));
-}
-
-template <class Set>
-inline void Query::storein_set (Set &sett, parms &p, query_reset r) {
-  mysql->storein_set (sett, str(p,r));
-}
-
-template <class Sequence>
-inline void Query::storein_sequence (Sequence &seq, const char *s) {
-  mysql->storein_sequence (seq, s);
-}
-
-template <class Set>
-inline void Query::storein_set (Set &sett, const char * s) {
-  mysql->storein_set (sett, s);
-}
-
-template <class T>
-inline void Query::storein (T &con, parms &p, query_reset r) {
-  mysql->storein (con, str(p,r));
-}
-
-template <class T>
-inline void Query::storein (T &con, const char *s) {
-  mysql->storein (con, s);
-}
-
-#endif
-
-
-
-

DELETED sqlplusint/query3.hh
Index: sqlplusint/query3.hh
==================================================================
--- sqlplusint/query3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "query2.hh"

DELETED sqlplusint/resiter1.hh
Index: sqlplusint/resiter1.hh
==================================================================
--- sqlplusint/resiter1.hh
+++ /dev/null
@@ -1,104 +0,0 @@
-#ifndef __resiter1_hh__
-#define __resiter1_hh__
-
-#include "defs"
-#include "row1.hh"
-#include <iterator.h>
-
-template <class OnType, class ReturnType, class SizeType, class DiffType>
-class subscript_iterator;
-
-//: A container adapter to make a container into a Random Access Container.
-
-// The requirements are that the container has the member functions
-// *operator[] (SizeType)* _and_  *size()* defined. 
-
-template <class OnType, class ValueType, class ReturnType = const ValueType&, class SizeType = unsigned int, class DiffType = int>
-class const_subscript_container {
-public:
-  typedef const_subscript_container<OnType,ValueType,ReturnType,SizeType,DiffType>
-                                    this_type; //:
-
-  typedef subscript_iterator<const this_type, ReturnType, SizeType, DiffType> 
-                                                 iterator;   //:
-  typedef iterator                               const_iterator; //:
-  typedef const ::reverse_iterator<iterator>       reverse_iterator; //:
-  typedef const ::reverse_iterator<const_iterator> const_reverse_iterator; //:
-  
-  typedef ValueType   value_type; //:
-  typedef value_type& reference;  //:
-  typedef value_type& const_reference; //:
-  typedef value_type* pointer; //:
-  typedef value_type* const_pointer; //:
-  
-  typedef DiffType          difference_type; //:
-  typedef SizeType          size_type; //:
-  
-  virtual size_type  size() const = 0; //:
-  virtual ReturnType operator[] (SizeType i) const = 0; //:
-
-  size_type max_size() const {return size();}    //:
-  bool      empty()    const {return size()==0;} //:
-  
-  iterator  begin() const {return iterator(this, 0);}      //:
-  iterator  end()   const {return iterator(this, size());} //:
-  
-  reverse_iterator rbegin() const {return reverse_iterator(end());}   //:
-  reverse_iterator rend()   const {return reverse_iterator(begin());} //:
-};
-
-//:
-template <class OnType, class ReturnType, class SizeType, class DiffType>
-class subscript_iterator : public random_access_iterator<ReturnType, SizeType>
-{
-private:
-  SizeType    i;
-  OnType     *d;
-public:
-  subscript_iterator() {}; 
-  subscript_iterator(OnType *what, SizeType pos) {d=what; i=pos;}
- 
-  bool operator == (const subscript_iterator &j) const
-    {if (d == j.d && i==j.i) return true; return false;}
-  bool operator != (const subscript_iterator &j) const
-    {if (d == j.d && i!=j.i) return true; return false;}
-  bool operator < (const subscript_iterator &j) const
-    {if (d == j.d && i < j.i) return true; return false;}
-  bool operator > (const subscript_iterator &j) const
-    {if (d == j.d && i > j.i) return true; return false;}
-  bool operator <= (const subscript_iterator &j) const
-    {if (d == j.d && i<=j.i) return true; return false;}
-  bool operator >= (const subscript_iterator &j) const
-    {if (d == j.d && i>=j.i) return true; return false;}
-
-  ReturnType operator -> () const {return &((*d)[i]);}
-  ReturnType operator *  () const {return (*d)[i];}
-  ReturnType operator [] (SizeType n) const {return (*d)[n];}
-
-  subscript_iterator& operator ++ () {i++; return *this;}
-  subscript_iterator  operator ++ (int) 
-    {subscript_iterator tmp = *this; i++; return tmp;}
-  subscript_iterator& operator -- () {i--; return *this;}
-  subscript_iterator  operator -- (int) 
-    {subscript_iterator tmp = *this; i--; return tmp;}
-  subscript_iterator& operator += (SizeType n) {i=i+n; return *this;}
-  subscript_iterator  operator + (SizeType n) const
-    {subscript_iterator tmp = *this; tmp.i+=n; return tmp;}
-  subscript_iterator& operator -= (SizeType n) {i=i-n; return *this;}
-  subscript_iterator  operator - (SizeType n) const
-    {subscript_iterator tmp = *this; tmp.i-=n; return tmp;}
-  DiffType operator - (const subscript_iterator &j) const
-    {if (d == j.d) return (SizeType)i - j.i; return 0;}
-};
-
-template <class OnType, class ReturnType, class SizeType, class DiffType>
-inline subscript_iterator<OnType,ReturnType,SizeType,DiffType> operator + 
-(SizeType x, const subscript_iterator <OnType,ReturnType,SizeType,DiffType>& y) 
-{
-  return y + x;
-}
-
-#endif
-
-
-

DELETED sqlplusint/result.cc
Index: sqlplusint/result.cc
==================================================================
--- sqlplusint/result.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-
-#include "result3.hh"
-
-pointer_tracker<MYSQL_RES, ResUse> ResUse::others =  pointer_tracker<MYSQL_RES, ResUse>();
-
-ResUse::ResUse (MYSQL_RES *result, Connection *m, bool te) 
-  : mysql(m), mysql_res(result), throw_exceptions(te), _names(NULL), _types(NULL), _fields(this)
-{
-  _table = fields(0).table;
-  if (mysql) mysql->add_child(this);
-  others.insert(mysql_res,this);
-}
-
-ResUse::~ResUse () {
-  if (mysql) mysql->unlock(); 
-  if (mysql) mysql->remove_child(this);
-  others.remove(mysql_res,this);
-}
-
-void ResUse::copy(const ResUse& other) {
-  throw_exceptions = other.throw_exceptions;
-  mysql_res = other.mysql_res;
-  _fields   = other._fields;
-  if (other._names)
-    _names     = new FieldNames(*other._names);
-  else
-    _names     = NULL;
-  if (other._types)
-    _types     = new FieldTypes(*other._types);
-  else
-    _types     = NULL;
-  mysql     = other.mysql;
-  if (mysql) mysql->add_child(this);
-  others.insert(mysql_res,this);
-}
-
-void MutableRes::populate(ResUse res) {
-  Row row = res.fetch_row();
-  _columns = row.size();
-  while (row) {
-    parent::push_back(MutableRow<MutableRes>(row, this));
-    row = res.fetch_row();
-  }
-}
-
-
-
-
-

DELETED sqlplusint/result1.hh
Index: sqlplusint/result1.hh
==================================================================
--- sqlplusint/result1.hh
+++ /dev/null
@@ -1,285 +0,0 @@
-#ifndef __result1_hh__
-#define __result1_hh__
-#ifdef __WIN32__
-#include <Windows32/Base.h>
-#include <Windows32/Defines.h>
-#include <Windows32/Structures.h>
-#include <winsock.h>
-#define errno WSAGetLastError()
-#endif
-#include <map.h>
-#include <set.h>
-#include <mysql.h>
-#include <string>
-#include "define_short"
-#include "field_names1.hh"
-#include "row1.hh"
-#include "resiter1.hh"
-#include "tracker.h"
-#include "field_types1.hh"
-#include "fields1.hh"
-
-#include "connection0.hh"
-
-//:
-class ResUse : public MysqlChild {
-  friend Connection;
-protected:
-  Connection            *mysql;
-  mutable MYSQL_RES     *mysql_res;
-  bool                  throw_exceptions;
-  mutable FieldNames    *_names;
-  mutable FieldTypes    *_types;
-  Fields                _fields;
-  string                _table;       
-
-  static pointer_tracker<MYSQL_RES, ResUse> others;
-
-  void copy(const ResUse& other); 
-public:
-  ResUse () : mysql(0), mysql_res(0), throw_exceptions(false), _names(NULL), _types(NULL), _fields(this) {}
-  ResUse (MYSQL_RES *result, Connection *m = NULL, bool te = false);
-  ResUse (const ResUse &other) {copy(other);}
-  inline ResUse& operator = (const ResUse &other);
-  MYSQL_RES *mysql_result (void) {return mysql_res;}
-  /* raw mysql c api functions */
-  Row fetch_row()
-    {return Row(mysql_fetch_row(mysql_res), this, throw_exceptions);}
-  //: raw c api function
-  bool          eof () const {return mysql_eof(mysql_res);}
-  //: raw c api function
-  long unsigned int *fetch_lengths () const {return mysql_fetch_lengths(mysql_res);}
-  //: raw c api function
-  void         free_result() {mysql_free_result(mysql_res);}
-  //: raw c api function
-
-  /* raw mysql c api fields functions */
-  Field&       fetch_field () const   {return *mysql_fetch_field(mysql_res);}
-  //: raw c api field function
-  void         field_seek (int field) {mysql_field_seek (mysql_res, field);}
-  //: raw c api field function
-  int          num_fields() const {return mysql_num_fields(mysql_res);}
-  //: raw c api field function
-
-  ~ResUse (); 
-
-  void parent_leaving() {mysql = NULL;}
-  
-  void purge(MYSQL_RES *r)
-    { if (mysql_res) mysql_free_result(mysql_res); mysql_res=0; if (_names) delete _names; if (_types) delete _types; _names=0; _types=0; _table.erase(); }
-  
-  operator bool() const {if (mysql_res) return true; return false;} //:
-  unsigned int columns() const {return num_fields();} //:
-
-  string& table() {return _table;}
-  //: table name
-  const string& table() const {return _table;}
-  //: table name
-
-  /* methods for working with field names */
-  inline int               field_num(const string&) const;
-  //: Returns the offset of the filed which equals str.
-  inline string&           field_name(int);
-  //: Returns the field with an offset of i.
-  inline const string&     field_name(int) const;
-  //: Returns the field with an offset of i.
-  inline FieldNames&       field_names();
-  //: Returns a reference to the underlying FieldNames class.
-  inline const FieldNames& field_names() const;
-  //: Returns a const reference to the underlaying FieldNames class.
-  inline void              reset_field_names();
-  //: Resets the field names to there original values.
-
-  /* methods for working with field types */
-  inline mysql_type_info&  field_type(int i);
-  //: Returns a reference to the  mysql field type for the field with an offset of i.
-  inline const mysql_type_info& field_type(int) const;
-  //: Returns a const reference to the  mysql field type for the field with an offset of i.
-  inline FieldTypes&       field_types();
-  //: Returns a reference to the underlying FieldTypes
-  inline const FieldTypes& field_types() const;
-  //: Returns a const reference to the underlying FieldTypes
-  inline void              reset_field_types();
-  //: Resets the field_types to their original values.
-
-  /* short names for the above methods */
-  inline int               names(const string& s) const;
-  //: Returns the offset of the filed which equals str.
-  inline string&           names(int i);
-  //: Returns the field with an offset of i.
-  inline const string&     names(int i) const;
-  //: Returns the field with an offset of i.
-  inline FieldNames&       names();
-  //: Returns a reference to the underlying FieldNames class.
-  inline const FieldNames& names() const;
-  //: Returns a const reference to the underlying FieldNames class.
-  inline void              reset_names();
-  //: Resets the field names to their original values.
-
-  inline mysql_type_info&  types(int i);
-  //: Returns a reference to the  mysql field type for the field with an offset of i.
-  inline const mysql_type_info& types(int i) const;
-  //: Returns a const reference to the mysql field type for the field with an offset of i.
-  inline FieldTypes&       types();
-  //: Returns a reference to the underlying FieldTypes
-  inline const FieldTypes& types() const;
-  //: Returns a const reference to the underlying FieldTypes
-  inline void              reset_types();
-  //: Resets the field_types to their original values.
-  
-  /* methods for working with field info */
-  const Fields&     fields() const {return _fields;}
-  //: returns a reference to the underling Fields structure.
-  const Field&      fields(unsigned int i) const {return _fields[i];}
-  //: returns a reference to the the mysql field info for a field with an offset of i.
-
-  bool     operator == (const ResUse &other) const
-    {return mysql_res == other.mysql_res;}
-  //:
-  bool     operator != (const ResUse &other) const
-    {return mysql_res != other.mysql_res;}
-  //:
-};
-
-//: This class handles the result set. 
-// It is also a Random Access Container that is not LessThanComparable
-// and not Assignable. Being a Random Access Container it can
-// return a Random Access Iterator or a reverse Random Access Iterator
-// yet.
-//
-// See MutableRes for a result set that can be modified.
-class Result : public ResUse, 
-	       public const_subscript_container<Result,Row,const Row>
-{
-  friend Connection;
-public:
-  Result () {} //:
-  Result (MYSQL_RES *result, bool te = false) 
-    : ResUse(result, NULL, te) {mysql = NULL;} //:
-  Result (const Result &other) : ResUse(other) {mysql = NULL;} //:
-  
-  // raw mysql c api functions
-  const Row    fetch_row() const
-    {return Row(mysql_fetch_row(mysql_res), this, throw_exceptions);}  
-  //: Raw c api function
-  int          num_rows() const {return mysql_num_rows(mysql_res);}
-  //: Raw c api function
-  void         data_seek (uint offset) const 
-    {mysql_data_seek(mysql_res, offset);}
-  //: Raw c api function
-
-  size_type size() const {return num_rows();}
-  //: Returns the number of columns.
-  size_type rows() const {return num_rows();}
-  //: Returns the number of rows.
-  const Row operator [] (size_type i) const {data_seek(i); return fetch_row();}
-  //: Returns the row with an offset of i.
-};
-
-class MutabelRes;
-
-//: This class handles the result set. 
-// It is also a Random Access Container that is not LessThanComparable
-// but is Assignable. Being a Random Access Container it can
-// return a Random Access Iterator or a reverse Random Access Iterator
-// yet.
-//
-class MutableRes : public vector<MutableRow<MutableRes> > {
-private:
-  size_type  _columns;
-  FieldNames _names;
-  void populate(ResUse res);
-
-  typedef vector<MutableRow<MutableRes> >  parent;
-public:
-  MutableRes() {}  //:
-  MutableRes(ResUse res) : _names(&res) {populate(res);} //:
-  MutableRes(size_type i) : _columns(i), _names (i) {} 
-  //: Creates a new mutable result set with i columns.
-
-  MutableRes& operator = (ResUse res) {
-    _names=&res; populate(res); return *this;
-  } //: 
-  MutableRes& operator = (size_type i) {
-    _columns = i; _names = i; return *this;
-  } //:
-
-  size_type rows() const {return size();}
-  //: Returns the number of rows.
-  size_type columns() const {return _columns;}
-  //: Returns the number of columns.
-
-  /* methodes for inserting elements as the standart insert functions
-     won't work that well as MutableRow needs to be constructed in a
-     special way */
-
-  iterator insert(iterator pos) {return parent::insert(pos, value_type(this));} 
-  void insert(iterator pos, size_type n) {parent::insert(pos, n, value_type(this));}
-  void push_back() {parent::push_back(value_type(this));}
-
-  /* methods for working with field names */
-
-  inline int               field_num(const string& str) const;
-  //: Returns the offset of the filed which equals str.
-  inline string&           field_name(int i);
-  //: Returns the field with an offset of i.
-  inline const string&     field_name(int i) const;
-  //: Returns the field with an offset of i.
-  inline FieldNames&       field_names();
-  //: Returns a reference to the underlying FieldNames class.
-  inline const FieldNames& field_names() const;
-  //: Returns a const reference to the underlying FieldNames class.
-
-  // short names for the above methods
-  inline int               names(const string& s) const;
-  //: Returns the offset of the filed which equals str.
-  inline string&           names(int i);
-  //: Returns the field with an offset of i.
-  inline const string&     names(int i) const;
-  //: Returns the field with an offset of i.
-  inline FieldNames&       names();
-  //: Returns a reference to the underlying FieldNames class.
-  inline const FieldNames& names() const;
-  //: Returns a const reference to the underlying FieldNames class.
-};
-
-//! with_class = ResUSe
-
-//:
-inline void swap (ResUse &x, ResUse &y) {
-  ResUse tmp = x;
-  x = y;
-  y = tmp;
-}
-
-//! with_class = Result
-
-//:
-inline void swap (Result &x, Result &y) {
-  Result tmp = x;
-  x = y;
-  y = tmp;
-}
-
-//: This structure holds the information on the success of queries that
-//: don't return any results.
-struct ResNSel {
-  bool     success;   
-  int      insert_id; //: 
-  int      rows;      //: Number of rows affected
-  string   info;      //: Additional info
-
-  ResNSel() : success(false) {};
-  ResNSel (Connection *q);
-
-  operator bool() {return success;}  //: If the query was successful
-};  
-
-
-#endif
-
-
-
-
-
-

DELETED sqlplusint/result2.hh
Index: sqlplusint/result2.hh
==================================================================
--- sqlplusint/result2.hh
+++ /dev/null
@@ -1,126 +0,0 @@
-#ifndef __result2_hh__
-#define __result2_hh__
-
-#include "connection2.hh"
-#include "result1.hh"
-#include "row2.hh"
-#include "fields2.hh"
-
-// field name info
-
-inline int ResUse::field_num(const string &i) const {
-  if (!_names) _names = new FieldNames(this);
-  return (*_names)[i];
-}
-
-inline string& ResUse::field_name(int i) {
-  if (!_names) _names = new FieldNames(this);
-  return (*_names)[i];
-}
-
-inline const string& ResUse::field_name(int i) const {
-  if (!_names) _names = new FieldNames(this);
-  return (*_names)[i];
-}
-
-inline FieldNames& ResUse::field_names() {
-  if (!_names) _names = new FieldNames(this);
-  return *_names;
-}
-
-inline const FieldNames& ResUse::field_names() const {
-  if (!_names) _names = new FieldNames(this);
-  return *_names;
-}
-
-inline void ResUse::reset_field_names() {
-  delete _names;
-  _names = new FieldNames(this);
-}
-
-// field type info
-
-inline mysql_type_info& ResUse::field_type(int i) {
-  if (!_types) _types = new FieldTypes(this);
-  return (*_types)[i];
-}
-
-inline const mysql_type_info& ResUse::field_type(int i) const {
-  if (!_types) _types = new FieldTypes(this);
-  return (*_types)[i];
-}
-
-inline FieldTypes& ResUse::field_types() {
-  if (!_types) _types = new FieldTypes(this);
-  return *_types;
-}
-
-inline const FieldTypes& ResUse::field_types() const {
-  if (!_types) _types = new FieldTypes(this);
-  return *_types;
-}
-
-inline void ResUse::reset_field_types() {
-  delete _types;
-  _types = new FieldTypes(this);
-}
-
-inline int               ResUse::names(const string& s) const {return field_num(s);}
-inline string&           ResUse::names(int i) {return field_name(i);}
-inline const string&     ResUse::names(int i) const {return field_name(i);}
-inline FieldNames&       ResUse::names() {return field_names();}
-inline const FieldNames& ResUse::names() const {return field_names();}
-inline void              ResUse::reset_names() {reset_field_names();}
-
-inline mysql_type_info&  ResUse::types(int i) {return field_type(i);}
-inline const mysql_type_info& ResUse::types(int i) const {return field_type(i);}
-inline FieldTypes&       ResUse::types() {return field_types();}
-inline const FieldTypes& ResUse::types() const {return field_types();}
-inline void              ResUse::reset_types() {reset_field_types();}
-
-//
-
-inline int MutableRes::field_num(const string &i) const {
-  return _names[i];
-}
-
-inline string& MutableRes::field_name(int i) {
-  return _names[i];
-}
-
-inline const string& MutableRes::field_name(int i) const {
-  return _names[i];
-}
-
-inline FieldNames& MutableRes::field_names() {
-  return _names;
-}
-
-inline const FieldNames& MutableRes::field_names() const {
-  return _names;
-}
-
-//
-
-inline int               MutableRes::names(const string& s) const {return field_num(s);}
-inline string&           MutableRes::names(int i) {return field_name(i);}
-inline const string&     MutableRes::names(int i) const {return field_name(i);}
-inline FieldNames&       MutableRes::names() {return field_names();}
-inline const FieldNames& MutableRes::names() const {return field_names();}
-
-//
-
-inline ResUse& ResUse::operator = (const ResUse &other) {
-  others.remove(mysql_res,this);
-  copy(other);
-  return *this;
-}
-
-inline ResNSel::ResNSel (Connection *q) 
-  : success   (q->success()),         insert_id (q->insert_id()),
-    rows      (q->affected_rows()),   info      (q->info())        {}
-
-#endif
-
-
-

DELETED sqlplusint/result3.hh
Index: sqlplusint/result3.hh
==================================================================
--- sqlplusint/result3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "result2.hh"

DELETED sqlplusint/row.cc
Index: sqlplusint/row.cc
==================================================================
--- sqlplusint/row.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-
-#include "result1.hh"
-#include "row3.hh"
-
-MutableRow<ResUse>::MutableRow(const Row &r) : MutableRow_base<ResUse>(r.res) {
-  if (r) {
-    reserve(r.size());
-    for (size_type i = 0; i < r.size(); i++) {
-      push_back(r.raw_data(i));
-    }
-  }
-}
-
-MutableRow<ResUse>::MutableRow(const ResUse &r) : MutableRow_base<ResUse>(&r) {
-  insert(begin(), r.columns(), MutableColData());
-}
-
-MutableRow<MutableRes>::MutableRow(const Row &r, const MutableRes *_res) 
-  : MutableRow_base<MutableRes>(_res) 
-{
-  if (r) {
-    reserve(r.size());
-    for (size_type i = 0; i < r.size(); i++) {
-      push_back(r.raw_data(i));
-    }
-  }
-}
-
-
-

DELETED sqlplusint/row1.hh
Index: sqlplusint/row1.hh
==================================================================
--- sqlplusint/row1.hh
+++ /dev/null
@@ -1,344 +0,0 @@
-#ifndef __row1_hh__
-#define __row1_hh__
-
-#include <vector>
-#include <string>
-#include "defs"
-#include "define_short"
-//#include "result1.hh"
-#include "coldata1.hh"
-#include "resiter1.hh"
-#include "vallist1.hh"
-
-template <class ThisType, class Res>
-class RowTemplate {
-protected:
-  virtual ThisType& self() = 0;
-  virtual const ThisType& self() const = 0;
-public:
-  virtual const Res & parent() const = 0;
-  
-  // 
-  // value_list
-  //
-  value_list_ba<ThisType,quote_type0> 
-  value_list(const char *d = ",") const {
-    return value_list_ba<ThisType,quote_type0> 
-      (self(), d, quote);
-  }
-
-  template <class Manip>  
-  value_list_ba<ThisType,Manip> 
-  value_list(const char *d, Manip m) const {
-    return value_list_ba<ThisType,Manip> (self(), d, m);
-  }
-
-  template <class Manip>  
-  value_list_b<ThisType,Manip> 
-  value_list(const char *d, Manip m, const vector<bool> &vb) const {
-    return value_list_b<ThisType,Manip> (self(), vb, d, m);
-  }
-
-  value_list_b<ThisType,quote_type0> 
-  value_list(const char *d, const vector<bool> &vb) const {
-    return value_list_b<ThisType,quote_type0> (self(), vb, d, quote);
-  }
-
-  value_list_b<ThisType,quote_type0> 
-  value_list(const vector<bool> &vb) const {
-    return value_list_b<ThisType,quote_type0> (self(), vb, ",", quote);
-  }
-
-  template <class Manip>  
-  value_list_b<ThisType,Manip> 
-  value_list(const char *d, Manip m, bool t0,
-	     bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	     bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	     bool t9=false, bool ta=false, bool tb=false, bool tc=false) const {
-    vector<bool> vb;
-    create_vector(self().size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-    return value_list_b<ThisType, Manip>(self(), vb, d, m);
-  }
-
-  value_list_b<ThisType,quote_type0> 
-  value_list(const char *d, bool t0,
-	     bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	     bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	     bool t9=false, bool ta=false, bool tb=false, bool tc=false) const {
-    vector<bool> vb;
-    create_vector(self().size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-    return value_list_b<ThisType, quote_type0>(self(), vb, d, quote);
-  }
-
-  value_list_b<ThisType,quote_type0> 
-  value_list(bool t0,
-	     bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	     bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	     bool t9=false, bool ta=false, bool tb=false, bool tc=false) const {
-    vector<bool> vb;
-    create_vector(self().size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-    return value_list_b<ThisType, quote_type0>(self(), vb, ",", quote);
-  }
-
-  template <class Manip>
-  value_list_b<ThisType,Manip> 
-  value_list(const char *d, Manip m, string s0,
-	     string s1="", string s2="", string s3="", string s4="",
-	     string s5="", string s6="", string s7="", string s8="",
-	     string s9="", string sa="", string sb="", string sc="") const {
-    vector<bool> vb;
-    create_vector(self(), vb, s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,sa,sb,sc);
-    return value_list_b<ThisType, Manip>(self(), vb, d, m);
-  }
-
-  value_list_b<ThisType,quote_type0> 
-  value_list(const char *d, string s0,
-	     string s1="", string s2="", string s3="", string s4="",
-	     string s5="", string s6="", string s7="", string s8="",
-	     string s9="", string sa="", string sb="", string sc="") const {
-    vector<bool> vb;
-    create_vector(self(), vb, s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,sa,sb,sc);
-    return value_list_b<ThisType, quote_type0>(self(), vb, d, quote);
-  }
-
-  value_list_b<ThisType,quote_type0> 
-  value_list(string s0,
-	     string s1="", string s2="", string s3="", string s4="",
-	     string s5="", string s6="", string s7="", string s8="",
-	     string s9="", string sa="", string sb="", string sc="") const {
-    vector<bool> vb;
-    create_vector(self(), vb, s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,sa,sb,sc);
-    return value_list_b<ThisType, quote_type0>(self(), vb, ",", quote);
-  }
-
-  //
-  // field_list
-  //
-  value_list_ba<FieldNames, do_nothing_type0> 
-  field_list(const char *d = ",") const {
-    return value_list_ba<FieldNames, do_nothing_type0> 
-      (parent().names(), d, do_nothing);
-  }
-
-  template <class Manip>  
-  value_list_ba<FieldNames,Manip> 
-  field_list(const char *d, Manip m) const {
-    return value_list_ba<FieldNames, Manip>
-      (parent().names(), d, m);
-  }
-
-  template <class Manip>  
-  value_list_b<FieldNames,Manip> 
-  field_list(const char *d, Manip m, const vector<bool> &vb) const {
-    return value_list_b<FieldNames,Manip> (parent().names(), vb, d, m);
-  }
-
-  value_list_b<FieldNames,quote_type0> 
-  field_list(const char *d, const vector<bool> &vb) const {
-    return value_list_b<FieldNames,quote_type0> (parent().names(), vb, d, quote);
-  }
-
-  value_list_b<FieldNames,quote_type0> 
-  field_list(const vector<bool> &vb) const {
-    return value_list_b<FieldNames,quote_type0> (parent().names(), vb, ",", quote);
-  }
-
-  template <class Manip>  
-  value_list_b<FieldNames,Manip> 
-  field_list(const char *d, Manip m, bool t0,
-	     bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	     bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	     bool t9=false, bool ta=false, bool tb=false, bool tc=false) const {
-    vector<bool> vb;
-    create_vector(parent().names().size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-    return value_list_b<FieldNames, Manip>(parent().names(), vb, d, m);
-  }
-
-  value_list_b<FieldNames,quote_type0> 
-  field_list(const char *d, bool t0,
-	     bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	     bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	     bool t9=false, bool ta=false, bool tb=false, bool tc=false) const {
-    vector<bool> vb;
-    create_vector(parent().names().size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-    return value_list_b<FieldNames, quote_type0>(parent().names(), vb, d, quote);
-  }
-
-  value_list_b<FieldNames,quote_type0> 
-  field_list(bool t0,
-	     bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	     bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	     bool t9=false, bool ta=false, bool tb=false, bool tc=false) const {
-    vector<bool> vb;
-    create_vector(parent().names().size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-    return value_list_b<FieldNames, quote_type0>(parent().names(), vb, ",", quote);
-  }
-
-  template <class Manip>
-  value_list_b<FieldNames,Manip> 
-  field_list(const char *d, Manip m, string s0,
-	     string s1="", string s2="", string s3="", string s4="",
-	     string s5="", string s6="", string s7="", string s8="",
-	     string s9="", string sa="", string sb="", string sc="") const {
-    vector<bool> vb;
-    create_vector(parent().names(), vb, s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,sa,sb,sc);
-    return value_list_b<FieldNames, Manip>(parent().names(), vb, d, m);
-  }
-
-  value_list_b<FieldNames,quote_type0> 
-  field_list(const char *d, string s0,
-	     string s1="", string s2="", string s3="", string s4="",
-	     string s5="", string s6="", string s7="", string s8="",
-	     string s9="", string sa="", string sb="", string sc="") const {
-    vector<bool> vb;
-    create_vector(parent().names(), vb, s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,sa,sb,sc);
-    return value_list_b<FieldNames, quote_type0>(parent().names(), vb, d, quote);
-  }
-
-  value_list_b<FieldNames,quote_type0> 
-  field_list(string s0,
-	     string s1="", string s2="", string s3="", string s4="",
-	     string s5="", string s6="", string s7="", string s8="",
-	     string s9="", string sa="", string sb="", string sc="") const {
-    vector<bool> vb;
-    create_vector(parent().names(), vb, s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,sa,sb,sc);
-    return value_list_b<FieldNames, quote_type0>(parent().names(), vb, ",", quote);
-  }
-
-  //
-  // equal_list
-  //
-  equal_list_ba<FieldNames,ThisType,quote_type0> 
-  equal_list(const char *d = ",", const char *e = " = ") const {
-    return equal_list_ba<FieldNames,ThisType,quote_type0> 
-      (parent().names(), self(), d, e, quote);
-  }
-
-  template <class Manip>
-  equal_list_ba<FieldNames,ThisType,Manip> 
-  equal_list(const char *d, const char *e, Manip m) const {
-    return equal_list_ba<FieldNames,ThisType,Manip> 
-      (parent().names(), self(), d, e, m);
-  }
-
-  virtual ~RowTemplate() {}
-};
-
-class MutableRes;
-template <class Res = ResUse> class MutableRow;
-
-//: This class handles the actual rows in an intelligent manner.
-class Row : public const_subscript_container<Row,ColData,const ColData>,
-	    public RowTemplate<Row, ResUse>
-{
-  friend MutableRow<ResUse>;
-  friend MutableRow<MutableRes>;
-private:
-//  MYSQL_ROW    data;
-  vector <string> data;
-  const ResUse *res;
-  bool         throw_exceptions;
-
-public:
-  Row() {}
-  Row(MYSQL_ROW d, const ResUse *r, bool te = false) 
-    : res(r), throw_exceptions(te) 
-		{
-		  if (!d) return;
-		  data.clear();
-		  for (unsigned int i=0;i<size();i++) 
-			{
-			  data.insert(data.end(),(d[i]) ? (string)d[i] : (string)"");
-			}
-		}
-  const Row& self() const {return *this;}
-  Row& self() {return *this;}
-
-  const ResUse&  parent() const {return *res;}
-  inline size_type     size() const;
-  //: Returns the number of columns.
-  const ColData   operator [] (int i) const {return operator[](size_type(i));}
-  inline const ColData   operator [] (size_type i) const;
-  //: Returns the value of the field with the index of i.
-  inline const ColData   operator [] (const char *) const;
-  //: Returns the value of the field with the field name of i.
-  // This method is not nearly as efficient as using the index number. Use sparingly. 
-  inline const ColData   operator [] (const string &i) const;
-  //: Returns the value of the field with the field name of i.
-  // This method is not nearly as effecent as using the index number. Use sparingly. 
-
-  const char * raw_data(int i) const {return data[i].c_str();}
-
-  operator bool() const {return (data.size()) ? true : false;}
-  //: Returns true if there is data in the row.
-	~Row() {data.clear();}	
-}; 
-
-//! with_class = MutableRow
-
-//: This class handles the actual rows with the added benefit of being able to modify the data.
-template <class Res>
-class MutableRow_base : public vector<MutableColData>, 
-			public RowTemplate<MutableRow_base<Res>, Res>
-{
-private:
-  const Res *res;
-  typedef vector<MutableColData> parent_type;
-protected:
-  MutableRow_base& self() {return *this;}
-  const MutableRow_base& self() const {return *this;}
-  MutableRow_base() {}
-  MutableRow_base (const Res *r) : res(r) {}
-public:
-  const Res& parent() const {return *res;}
-
-  string& table() {return res->table();}
-  const string& table() const {return res->table();}
-
-  MutableColData&  operator [] (int i) 
-    {return parent_type::operator [](i);}
-  //: Returns the value of the field with the index of i.
-  MutableColData&  operator [] (unsigned int i) 
-    {return parent_type::operator [](i);}
-  const MutableColData&  operator [] (int i) const
-    {return parent_type::operator [](i);}
-  //: Returns the value of the field with the index of i.
-  const MutableColData&  operator [] (unsigned int i) const
-    {return parent_type::operator [](i);}
-
-  MutableColData&  operator [] (const char *);
-  MutableColData&  operator [] (const string &i);
-  //: Returns the value of the field with the field name of i.
-  // This method is not nearly as efficient as using the index number. Use sparingly. 
-
-  const MutableColData&  operator [] (const char *) const;
-  const MutableColData&  operator [] (const string &i) const;
-  //: Returns the value of the field with the field name of i.
-  // This method is not nearly as efficient as using the index number. Use sparingly. 
-
-  operator bool() const {return empty();}
-  //: Returns true if there is data in the row.
-};
-
-template <class Res> class MutableRow {};
-
-
-//:
-//!dummy: template <class Res = ResUse> class MutableRow : public MutableRow_base<Res> {};
-
-class MutableRow<ResUse> : public MutableRow_base<ResUse> {
-public:
-  MutableRow(const Row& row);
-  MutableRow(const ResUse &res);
-};
-
-class MutableRow<MutableRes> : public MutableRow_base<MutableRes> {
-public:
-  MutableRow(const Row& row, const MutableRes *_res); 
-  inline MutableRow(const MutableRes *_res);        
-};
-
-
-#endif
-
-

DELETED sqlplusint/row2.hh
Index: sqlplusint/row2.hh
==================================================================
--- sqlplusint/row2.hh
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef __row2_hh__
-#define __row2_hh__
-
-#include "string.h"
-#include "row1.hh"
-#include "result2.hh"
-
-inline Row::size_type Row::size() const {return res->num_fields();}
-
-inline const ColData Row::operator [] (size_type i) const {
-  return ColData(data[i].c_str(), res->types(i));
-}
-
-inline const ColData Row::operator[] (const string &i) const {
-  return (*this)[res->field_num(i)];
-}
-
-inline const ColData Row::operator[] (const char *i) const {
-  return (*this)[res->field_num(string(i))];
-}
-
-// MutableRow
-
-inline MutableRow<MutableRes>::MutableRow(const MutableRes *_res)
-  : MutableRow_base<MutableRes>(_res)
-{
-  insert(begin(), _res->columns(), "");
-}
-
-template <class Res>
-inline MutableColData& MutableRow_base<Res>::operator[] (const string &i) {
-  return (*this)[res->field_num(i)];
-}
-
-template <class Res>
-inline MutableColData& MutableRow_base<Res>::operator[] (const char *i) {
-  return (*this)[res->field_num(string(i))];
-}
-
-template <class Res>
-inline const MutableColData& MutableRow_base<Res>::operator[] (const string &i) const {
-  return (*this)[res->field_num(i)];
-}
-
-template <class Res>
-inline const MutableColData& MutableRow_base<Res>::operator[] (const char *i) const {
-  return (*this)[res->field_num(string(i))];
-}
-
-// RowTemplate
-
-#endif
-
-
-
-
-
-
-
-
-
-

DELETED sqlplusint/row3.hh
Index: sqlplusint/row3.hh
==================================================================
--- sqlplusint/row3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "row2.hh"

DELETED sqlplusint/set.cc
Index: sqlplusint/set.cc
==================================================================
--- sqlplusint/set.cc
+++ /dev/null
@@ -1,4 +0,0 @@
-
-#include "set3.hh"
-
-template class Set<set<string> >;

DELETED sqlplusint/set1.hh
Index: sqlplusint/set1.hh
==================================================================
--- sqlplusint/set1.hh
+++ /dev/null
@@ -1,79 +0,0 @@
-#ifndef __set1_hh__
-#define __set1_hh__
-#ifdef __WIN32__
-#include <Windows32/Base.h>
-#include <Windows32/Defines.h>
-#include <Windows32/Structures.h>
-#include <winsock.h>
-#define errno WSAGetLastError()
-#endif
-#include <set>
-#include <vector>
-#include <iostream.h>
-#include "define_short"
-#include "coldata1.hh"
-
-template <class T, class value_type = typename T::value_type>
-class MysqlListInsert {
-private:
-  T *object;
-public:
-  MysqlListInsert(T *o) {object = o;}
-  void operator () (const value_type &data) {object->push_back(data);}
-};
-
-template <class T, class key_type = typename T::key_type> 
-class MysqlSetInsert {
-private:
-  T *object;
-public:
-  MysqlSetInsert(T *o) {object = o;}
-  void operator () (const key_type &data) {object->insert(data);}
-};
-
-template <class T>
-inline MysqlSetInsert<set<T> > set_insert(set<T> *o) {
-  return MysqlSetInsert<set<T> >(o);
-}
-
-template <class T>
-inline MysqlListInsert<vector<T> > set_insert(vector<T> *o) {
-  return MysqlListInsert<vector<T> >(o);
-}
-
-template <class Insert>
-void set2container (const char *str, Insert insert);
-
-//: A Special Set for holding mysql sets.
-template <class Container = set<string> >
-class Set : public Container {
-public:
-  Set(const char* str) {set2container(str,set_insert(this));}           //:
-  Set(const string &str) {set2container(str.c_str(),set_insert(this));} //:
-  Set(const ColData &str) 
-    {set2container(str.c_str(),set_insert(this));}                      //:
-  
-  ostream& out_stream(ostream &s) const;
-  
-  operator string ();
-};
-
-//! with_class = Set
-
-//:
-template <class Container>
-inline ostream& operator << (ostream &s, const Set<Container> &d) 
-{ 
-  return d.out_stream(s); 
-}
-
-#endif
-
-
-
-
-
-
-
-
-

DELETED sqlplusint/set2.hh
Index: sqlplusint/set2.hh
==================================================================
--- sqlplusint/set2.hh
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef __set2_hh__
-#define __set2_hh__
-
-#include "set1.hh"
-#include "stream2string3.hh"
-
-template <class Container> 
-inline Set<Container>::operator string () {
-  return stream2string<string>(*this);
-}
-
-#endif

DELETED sqlplusint/set3.hh
Index: sqlplusint/set3.hh
==================================================================
--- sqlplusint/set3.hh
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef __set3_hh__
-#define __set3_hh__
-
-#include "set2.hh"
-#include "coldata2.hh"
-
-template <class Insert>
-void set2container (const char *str, Insert insert) {
-  MutableColData s;
-  while (1) {
-    s = "";
-    while (*str != ',' && *str) {
-      s += *str;
-      str++;
-    }
-    insert(s);
-    if (!*str) break;
-    str++;
-  }
-}
-
-template <class Container>
-ostream& Set<Container>::out_stream (ostream &s) const {
-  typename Container::const_iterator i = begin();
-  typename Container::const_iterator e = end();
-  while (true) {
-    s << *i;
-    i++;
-    if (i==e) break;
-    s << ",";
-  }
-  return s;
-}
-
-#endif

DELETED sqlplusint/space-fix.pl
Index: sqlplusint/space-fix.pl
==================================================================
--- sqlplusint/space-fix.pl
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/perl
-
-$/ = undef;
-
-open F, $ARGV[0];
-
-$_=<F>;
-
-s/ +/ /g;
-s/\n /\n/g;
-s/\n\n+/\n\n/g;
-
-open F, ">$ARGV[0]";
-print F;
-
-

DELETED sqlplusint/sql_query.cc
Index: sqlplusint/sql_query.cc
==================================================================
--- sqlplusint/sql_query.cc
+++ /dev/null
@@ -1,178 +0,0 @@
-
-#include "sql_query3.hh"
-//#include "result3.hh"
-
-SQLQuery::SQLQuery(const SQLQuery &q) {
-  *this << q.str();
-  Success = q.Success;
-  def = q.def;
-}
-
-
-SQLQuery& SQLQuery::operator = (const SQLQuery &q) {
-  reset();
-  *this << q.str();
-  Success = q.Success;
-  def = q.def;
-  return *this;
-}
-
-
-void SQLQuery::reset() {
-  seekg (0L,ios::beg);
-  seekp (0L,ios::beg);
-  parsed.erase(parsed.begin(), parsed.end());
-  def.clear(); clear();
-}
-
-char * SQLQuery::preview_char() {
-  *this << ends;
-#ifdef __USLC__
-  strstreambuf *tmpbuf = rdbuf();
-  uint length = tmpbuf->pcount();
-#else
-  uint length = pcount();
-#endif
-  char *s = new char[length]; 
-  get(s, length, '\0'); 
-  seekg (0,ios::beg);
-  seekp (-1,ios::cur);
-  return s;
-}
-
-SQLString * pprepare (char option, SQLString &S, bool replace = true) {
-  if (S.processed) return &S;
-  if (option == 'r' || (option == 'q' && S.is_string)) {
-    char *s = new char[S.size()*2];
-    mysql_escape_string(s,const_cast<char *>(S.c_str()),S.size());
-    SQLString *ss = new SQLString("'");
-    *ss += s;
-    *ss += "'";
-    delete[] s;
-    if (replace) {S = *ss; S.processed = true; return &S;}
-    return ss;
-  } else if (option == 'R' || (option == 'Q' && S.is_string)) {
-    SQLString *ss = new SQLString("'" + S + "'");
-    if (replace) {S = *ss; S.processed = true; return &S;}
-    return ss;
-  } else {
-    if (replace) S.processed = true;
-    return &S;
-  }
-}
-
-void SQLQuery::proc(SQLQueryParms& p) {
-  seekg (0,ios::beg);
-  seekp (0,ios::beg);
-  char      num;
-  SQLString *ss;
-  SQLQueryParms *c;
-  for (vector<SQLParseElement>::iterator i = parsed.begin();
-       i != parsed.end(); i++) {
-    *this << i->before;
-    num    = i->num;
-    if (num == -1) {
-      // do nothing    
-    } else {
-      if (num < (int)p.size()) c = &p;
-      else if (num < (int)def.size()) c = &def;
-      else {
-	*this << " ERROR";
-	throw SQLQueryNEParms("Not enough parameters to fill the template.");
-      }
-      ss = pprepare(i->option, (*c)[num], c->bound());
-      *this << *ss;
-      if (ss != &(*c)[num]) delete ss;
-    }
-  }
-} 
-
-string SQLQuery::str(const SQLQueryParms &p) const {
-  SQLQuery *const_this = const_cast<SQLQuery *>(this);
-  if (!parsed.empty()) const_this->proc(const_cast<SQLQueryParms&>(p));
-  *const_this << ends;
-#ifdef __USLC__
-  strstreambuf *tmpbuf = const_this->rdbuf();
-  uint length = tmpbuf->pcount();
-  char *s = new char[length]; 
-#else
-  uint length = const_this->pcount();
-  char s[length]; 
-#endif
-  const_this->get(s, length, '\0'); 
-  const_this->seekg (0,ios::beg);
-  const_this->seekp (-1,ios::cur);
-  return string(s);
-}
-
-string SQLQuery::str(const SQLQueryParms &p, query_reset r) {
-  string tmp = str(p);
-  if (r==RESET_QUERY) reset();
-  return tmp;
-}
-
-SQLQueryParms SQLQueryParms::operator + (const SQLQueryParms &other) const {
-  if (other.size() <= size()) return *this;
-  SQLQueryParms New = *this;
-  unsigned int i;
-  for(i = size(); i < other.size(); i++) {
-    New.push_back(other[i]);
-  }
-  return New;
-}
-
-void SQLQuery::parse() {
-  string str = "";
-  char num[3];
-  long int n;
-  char option;
-  string name;
-  char *s, *s0;
-  s0 = s = preview_char();
-  while (*s) {
-    if (*s == '%') {
-      s++;
-      if (*s == '%') {
-	str += *s++;
-      } else if (*s >= '0' && *s <= '9') {
-	num[0] = *s;
-	s++;
-	if (*s >= '0' && *s <= '9') {
-	  num[1] = *s;
-	  num[2] = 0;
-          s++;
-	} else {
-	  num[1] = 0;
-	}
-        n = strtol(num,NULL,10);
-        option = ' ';
-        if (*s == 'q' || *s == 'Q' || *s == 'r' || *s == 'R')
-	  option = *s++;
-	if (*s == ':') {
-	  s++;
-	  for (;(*s>='A' && *s<='Z') || *s=='_' || (*s>='a' && *s<='z'); s++) {
-	    name += *s;
-	  }
-	  if (*s == ':') s++;
-          if (n >= (long int)parsed_names.size())
-	    parsed_names.insert(parsed_names.end(),
-				(vector<string>::size_type)(n+1) 
-				- parsed_names.size(), string());
-	  parsed_names[n] = name;
-	  parsed_nums[name] = n;
-	}
-	    
-	parsed.push_back( SQLParseElement(str,option,n) );
-	str = "";
-	name = "";
-      } else {
-	str += '%';
-      }
-    } else {
-      str += *s++;
-    }
-  }
-  parsed.push_back( SQLParseElement(str,' ',-1) );
-  delete[] s0;
-}
-

DELETED sqlplusint/sql_query0.hh
Index: sqlplusint/sql_query0.hh
==================================================================
--- sqlplusint/sql_query0.hh
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef __sql_query0_hh__
-#define __sql_query0_hh__
-
-#define mysql_query_define0(RETURN, FUNC)\
-  RETURN FUNC (ss a)\
-    {return FUNC (parms() << a);}\
-  RETURN FUNC (ss a, ss b)\
-    {return FUNC (parms() << a << b);}\
-  RETURN FUNC (ss a, ss b, ss c)\
-    {return FUNC (parms() << a << b << c);}\
-  RETURN FUNC (ss a, ss b, ss c, ss d)\
-    {return FUNC (parms() << a << b << c << d);}\
-  RETURN FUNC (ss a, ss b, ss c, ss d, ss e)\
-    {return FUNC (parms() << a << b << c << d << e);} \
-  RETURN FUNC (ss a, ss b, ss c, ss d, ss e, ss f)\
-    {return FUNC (parms() << a << b << c << d << e << f);}\
-  RETURN FUNC (ss a, ss b, ss c, ss d, ss e, ss f, ss g)\
-    {return FUNC (parms() << a << b << c << d << e << f << g);}\
-  RETURN FUNC (ss a, ss b, ss c, ss d, ss e, ss f, ss g, ss h)\
-    {return FUNC (parms() << a << b << c << d << e << f << g << h);}\
-  RETURN FUNC (ss a, ss b, ss c, ss d, ss e, ss f, ss g, ss h, ss i)\
-    {return FUNC (parms() << a << b << c << d << e << f << g << h << i);}\
-  RETURN FUNC (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j)\
-    {return FUNC (parms() <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j);}\
-  RETURN FUNC (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j,ss k)\
-    {return FUNC (parms() <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j <<k);}\
-  RETURN FUNC (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j,ss k,\
-		       ss l)\
-    {return FUNC (parms() <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j <<k <<l);}\
-
-#define mysql_query_define_const1(RETURN, FUNC) \
-  RETURN FUNC () const {return FUNC (def);} \
-  RETURN FUNC (query_reset r) {return FUNC (def,r);} \
-  RETURN FUNC (const char* str) const; \
-  RETURN FUNC (const parms &p) const; \
-  RETURN FUNC (const parms &p, query_reset r);\
-  mysql_query_define0(RETURN,FUNC) \
-
-#define mysql_query_define1(RETURN, FUNC) \
-  RETURN FUNC (query_reset r = RESET_QUERY) {return FUNC (def,r);} \
-  RETURN FUNC (const char* str); \
-  RETURN FUNC (parms &p, query_reset r = RESET_QUERY);\
-  mysql_query_define0(RETURN,FUNC) \
-
-#define mysql_query_define2(FUNC) \
-  template <class T1> void FUNC (T1 &con, query_reset r = RESET_QUERY) {FUNC (con, def,r);} \
-  template <class T1> void FUNC (T1 &con, const char* str); \
-  template <class T1> void FUNC (T1 &con, parms &p, query_reset r = RESET_QUERY);\
-  template <class T1> void FUNC (T1 &con, ss a)\
-    {FUNC (con, parms() << a);}\
-  template <class T1> void FUNC (T1 &con, ss a, ss b)\
-    {FUNC (con, parms() << a << b);}\
-  template <class T1> void FUNC (T1 &con, ss a, ss b, ss c)\
-    {FUNC (con, parms() << a << b << c);}\
-  template <class T1> void FUNC (T1 &con, ss a, ss b, ss c, ss d)\
-    {FUNC (con, parms() << a << b << c << d);}\
-  template <class T1> void FUNC (T1 &con, ss a, ss b, ss c, ss d, ss e)\
-    {FUNC (con, parms() << a << b << c << d << e);} \
-  template <class T1> void FUNC (T1 &con, ss a, ss b, ss c, ss d, ss e, ss f)\
-    {FUNC (con, parms() << a << b << c << d << e << f);}\
-  template <class T1> void FUNC (T1 &con,ss a,ss b,ss c,ss d,ss e,ss f,ss g)\
-    {FUNC (con, parms() << a << b << c << d << e << f << g);}\
-  template <class T1> void FUNC (T1 &con,ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h)\
-    {FUNC (con, parms() << a << b << c << d << e << f << g << h);}\
-  template <class T1> void FUNC (T1 &con, ss a, ss b, ss c, ss d, ss e, ss f, ss g, ss h, ss i)\
-    {FUNC (con, parms() << a << b << c << d << e << f << g << h << i);}\
-  template <class T1> void FUNC (T1 &con, ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j)\
-    {FUNC (con, parms() <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j);}\
-  template <class T1> void FUNC (T1 &con, ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j,ss k)\
-    {FUNC (con, parms() <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j <<k);}\
-  template <class T1> void FUNC (T1 &con, ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j,ss k,\
-		       ss l)\
-    {FUNC (con, parms() <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j <<k <<l);}\
-
-
-#endif

DELETED sqlplusint/sql_query1.hh
Index: sqlplusint/sql_query1.hh
==================================================================
--- sqlplusint/sql_query1.hh
+++ /dev/null
@@ -1,198 +0,0 @@
-#ifndef __sql_query_1_hh
-#define __sql_query_1_hh
-
-#include <strstream.h>
-#include <vector>
-#include <map>
-#include "define_short"
-#include "sql_query0.hh"
-#include "sql_string1.hh"
-
-class Query;
-class SQLQuery;
-
-
-//! with_class = SQLQuery
-
-//: Exception thrown when not enough parameters are provided
-// Thrown when not enough parameters are provided for a 
-// template query.
-struct SQLQueryNEParms {
-  SQLQueryNEParms(const char *c) : error(c) {}
-  const char* error; //:
-};
-
-//: This class holds the parameter values for filling template queries. 
-// It is a subclass of a vector of *SQLStrings*.
-class SQLQueryParms : public vector<SQLString> {
-  friend Query;
-private:
-  typedef const SQLString&      ss;
-  SQLQuery                 *parent;
-public:
-  SQLQueryParms () : parent(NULL) {} 
-  SQLQueryParms (SQLQuery *p) : parent(p) {}
-  bool  bound() {return parent;}
-  void               clear() {erase(begin(),end());} //: Clears the list
-  SQLString &operator [] (size_type n) {
-    if (n >= size()) insert(end(),(n+1) - size(), "");
-    return vector<SQLString>::operator [] (n);
-  } //: Access element number n
-  const SQLString &operator [] (size_type n) const 
-    {return vector<SQLString>::operator [] (n);}     
-  //: Access element number n
-  SQLString &operator [] (const char *str); 
-  //: Access the value of the element with a key of str.
-
-  const SQLString &operator [] (const char *str) const; 
-  //: Access the value of the element with a key of str.
-
-  SQLQueryParms &operator << (const SQLString &str)
-    {push_back(str);return *this;}  //: Adds an element to the list
-
-  SQLQueryParms &operator += (const SQLString &str)
-    {push_back(str);return *this;}  //: Adds an element to the list
-
-  SQLQueryParms operator + (const SQLQueryParms &other) const;
-
-  //!dummy: void set (ss a, [ss b] ,... , [ss l]);
-  //: Set the elements.
-  // Sets element 0 to a, element 1 to b, etc. May specify up to a dozen elements
-
-  void set (ss a)
-    {clear(); *this << a;}
-  void set (ss a, ss b)
-    {clear(); *this << a << b;}
-  void set (ss a, ss b, ss c)
-    {clear(); *this << a << b << c;}
-  void set (ss a, ss b, ss c, ss d)
-    {clear(); *this << a << b << c << d;}
-  void set (ss a, ss b, ss c, ss d, ss e)
-    {clear(); *this << a << b << c << d << e;}
-  void set (ss a, ss b, ss c, ss d, ss e, ss f)
-    {clear(); *this << a << b << c << d << e << f;}
-  void set (ss a, ss b, ss c, ss d, ss e, ss f, ss g)
-    {clear(); *this << a << b << c << d << e << f << g;}
-  void set (ss a, ss b, ss c, ss d, ss e, ss f, ss g, ss h)
-    {clear(); *this << a << b << c << d << e << f << g << h;}
-  void set (ss a, ss b, ss c, ss d, ss e, ss f, ss g, ss h, ss i)
-    {clear(); *this << a << b << c << d << e << f << g << h << i;}
-  void set (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j)
-    {clear(); *this <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j;}
-  void set (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j,ss k)
-    {clear(); *this <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j <<k;}
-  void set (ss a,ss b,ss c,ss d,ss e,ss f,ss g,ss h,ss i,ss j,ss k,ss l)
-    {clear(); *this <<a <<b <<c <<d <<e <<f <<g <<h <<i <<j <<k <<l;}
-};
-
-//:
-enum query_reset {DONT_RESET, RESET_QUERY};
-
-struct SQLParseElement {
-  SQLParseElement(string b, char o, char n) : before(b),option(o),num(n) {}
-  string before;
-  char   option;
-  char   num;
-};
-
-//! with_class = Query
-
-//: The "pure" query class 
-
-// This is the "pure" query class. It is used to form queries to send
-// to the *Connection* object. The *Query* class can be used if you
-// wish to also be able to execute the queries without having to send
-// them to the *Connection* object.
-//
-// This class is subclassed from *strstream*. This means that you can
-// write to it like a stream to avoid having to piece parts together
-// by creating you own *strstream* or by using *sprintf*. Although you
-// can read from query because it is a stream this is _not_
-// recommended. I can not guarantee the predictability of the class if
-// you do and will offer no help if you run into problems when you do
-// this. However, fell free to use any of the stream methods to write
-// to it. Just make sure that the write buffer points to the end of
-// your query before you try to use any of the *SQLQuery* specific
-// methods except for *error()* and *success()*.
-
-class SQLQuery : public strstream { 
-  friend SQLQueryParms; 
-private:
-  char* preview_char();
-protected:
-  bool    Success;
-  char*   errmsg;
-  vector<SQLParseElement> parsed;
-  vector<string>          parsed_names;
-  map<string,int>         parsed_nums;
-  typedef  const SQLString&  ss;
-  typedef  SQLQueryParms  parms;
-  void     proc(parms &p);
-
-public:
-  SQLQuery(): Success(false), errmsg(NULL), def(this) {} //:
-  SQLQuery(const SQLQuery &q); //:
-  SQLQuery& operator = (const SQLQuery &q); //:
-
-  SQLQueryParms def; //: The default template parameters set. 
-
-  void     parse();  
-
-  string   error () const {return errmsg;}
-  bool     success() const {return Success;}
-
-  operator bool () {return success();}
-  bool operator !    () {return !success();}
-
-  //!dummy: string str (query_reset r = DONT_RESET);
-  //: Returns the full query string.
-  // Returns the full query string, replacing it with the default
-  // template parameters if necessary. *query_reset* can either be
-  // DONT_RESET or RESET_QUERY. If it is set the RESET_QUERY then
-  // reset() is called after it has finished returning the query. If
-  // there is not enough  parameters then it will return a
-  // empty string and *success()* would be false.
-
-  //!dummy: string str (const SQLString &parm0, ...,const SQLString &parm11);
-  //: Like str(query_reset) but sets the parameters.
-  // Like str(query_reset) but sets query parameters 0 to (up to)
-  // 11. To parm0, parm1 etc. This is archived by overloaded methods
-  // and templates and not the ...
-  //
-  // It will combine this with def. If any of the required parameters
-  // are null it will produce an error and return an empty string.
-
-  //!dummy: string str(const SQLQueryParms & p, query_reset r = DONT_RESET);
-  //: Like *str(query_reset)* but sets the parameter.
-  // Like *query(query_reset res)* but sets the parameters based on
-  // combining p and def.
-  //
-  // If any of the required parameters are null it will produce an
-  // error and return an empty string.
-
-  void     reset (); //: Resets the query. 
-  // This means erasing the string and the default template parameters. 
-
-  template <class T> SQLQuery& update(const T &o, const T &n) {
-    reset();
-    *this << "UPDATE " << o.table() << " SET " << n.equal_list() 
-          << " WHERE " << o.equal_list(" AND ", sql_use_compare);
-    return *this;
-  } //:
-  template <class T> SQLQuery& insert(const T &v) {
-    reset();
-    *this << "INSERT INTO " << v.table() << " (" << v.field_list()
-          << ") VALUES (" << v.value_list() << ")";
-    return *this;
-  } //:
-  template <class T> SQLQuery& replace(const T &v) {
-    reset();
-    *this << "REPLACE INTO " << v.table() << " (" << v.field_list()
-          << ") VALUES (" << v.value_list() << ")";
-    return *this;
-  } //:
-
-  mysql_query_define_const1(string,str)
-};  
-
-#endif

DELETED sqlplusint/sql_query2.hh
Index: sqlplusint/sql_query2.hh
==================================================================
--- sqlplusint/sql_query2.hh
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef __sql_query2_hh__
-#define __sql_query2_hh__
-
-#include "sql_query1.hh"
-
-inline SQLString &SQLQueryParms::operator[] (const char *str) {
-  if (parent) return operator[] (parent->parsed_nums[str]);
-  throw; // only here temporary 
-}
-inline const SQLString &SQLQueryParms::operator[] (const char *str) const {
-  if (parent) return operator[] (parent->parsed_nums[str]);
-  throw; // only here temporary 
-}
-
-#endif

DELETED sqlplusint/sql_query3.hh
Index: sqlplusint/sql_query3.hh
==================================================================
--- sqlplusint/sql_query3.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "sql_query2.hh"

DELETED sqlplusint/sql_string1.hh
Index: sqlplusint/sql_string1.hh
==================================================================
--- sqlplusint/sql_string1.hh
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef __sql_string1_hh__
-#define __sql_string1_hh__
-
-#include <stdio.h>
-#include <string>
-#include "defs"
-#include "define_short"
-
-//: A special string that will convert from anything.
-// A class subclassed from string that has the additional ability to
-// convert from any valid mysql type.
-
-class SQLString : public string {
-public:
-  bool is_string;
-  bool dont_escape;
-  bool processed;
-
-  SQLString() : is_string(false) , processed(false) {}
-  SQLString (const string& str) :string (str)
-    {is_string=true;processed=false;dont_escape=false;}
-  SQLString (const char *str) :string (str) 
-    {is_string=true;processed=false;dont_escape=false;}
-  SQLString& operator = (const char *str) {
-    string::operator = (str); return *this;
-  }
-  SQLString& operator = (const string& str) {
-    string::operator = (str); return *this;
-  }
-  SQLString (char i) : is_string(false), processed(false)
-    {char s[6]; sprintf(s,"%dh",(short int)i); *this=s;}
-  SQLString (unsigned char i) : is_string(false), processed(false)
-    {char s[6]; sprintf(s,"%uh",(short int)i); *this=s;}
-  SQLString (short int i) : is_string(false), processed(false)
-    {char s[6]; sprintf(s,"%dh",i); *this=s;}
-  SQLString (unsigned short int i) : is_string(false), processed(false)
-    {char s[6]; sprintf(s,"%uh",i); *this=s;}
-  SQLString (int i) : is_string(false), processed(false)
-    {char s[11]; sprintf(s,"%d",i); *this=s;}
-  SQLString (unsigned int i) : is_string(false), processed(false)
-    {char s[11]; sprintf(s,"%u",i); *this=s;}
-/*SQLString (long long int i) : is_string(false), processed(false)
-    {char s[22]; sprintf(s,"%dL",i); *this=s;}
-  SQLString (unsigned long long int i) : is_string(false), processed(false) 
-    {char s[22]; sprintf(s,"%uL",i); *this=s;}
-*/
-  SQLString (float i) : is_string(false), processed(false)
-    {char s[40]; sprintf(s,"%g",i); *this=s;}
-  SQLString (double i) : is_string(false), processed(false)
-    {char s[40]; sprintf(s,"%g",i); *this=s;}
-};
-
-#endif
-
-
-
-
-

DELETED sqlplusint/sql_string2.hh
Index: sqlplusint/sql_string2.hh
==================================================================
--- sqlplusint/sql_string2.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "sql_string1.hh"
-

DELETED sqlplusint/sql_string3.hh
Index: sqlplusint/sql_string3.hh
==================================================================
--- sqlplusint/sql_string3.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "sql_string2.hh"
-

DELETED sqlplusint/sqlplus.hh
Index: sqlplusint/sqlplus.hh
==================================================================
--- sqlplusint/sqlplus.hh
+++ /dev/null
@@ -1,73 +0,0 @@
-
-#include "defs"
-#include "define_short"
-
-#include "coldata1.hh"
-#include "compare1.hh"
-#include "connection1.hh"
-#include "const_string1.hh"
-#include "convert1.hh"
-#include "datetime1.hh"
-#include "field_names1.hh"
-#include "field_types1.hh"
-#include "fields1.hh"
-#include "manip1.hh"
-#include "null1.hh"
-#include "query1.hh"
-#include "resiter1.hh"
-#include "result1.hh"
-#include "row1.hh"
-#include "set1.hh"
-#include "sql_query1.hh"
-#include "sql_string1.hh"
-#include "stream2string1.hh"
-#include "tiny_int1.hh"
-#include "type_info1.hh"
-#include "vallist1.hh"
-
-#include "coldata2.hh"
-#include "compare2.hh"
-#include "connection2.hh"
-#include "const_string2.hh"
-#include "convert2.hh"
-#include "datetime2.hh"
-#include "field_names2.hh"
-#include "field_types2.hh"
-#include "fields2.hh"
-#include "manip2.hh"
-#include "null2.hh"
-#include "query2.hh"
-#include "result2.hh"
-#include "row2.hh"
-#include "set2.hh"
-#include "sql_query2.hh"
-#include "sql_string2.hh"
-#include "stream2string2.hh"
-#include "tiny_int2.hh"
-#include "type_info2.hh"
-#include "vallist2.hh"
-
-#include "coldata3.hh"
-#include "compare3.hh"
-#include "connection3.hh"
-#include "const_string3.hh"
-#include "convert3.hh"
-#include "datetime3.hh"
-#include "field_names3.hh"
-#include "field_types3.hh"
-#include "manip3.hh"
-#include "null3.hh"
-#include "query3.hh"
-#include "result3.hh"
-#include "row3.hh"
-#include "set3.hh"
-#include "sql_query3.hh"
-#include "sql_string3.hh"
-#include "stream2string3.hh"
-#include "tiny_int3.hh"
-#include "type_info3.hh"
-#include "vallist3.hh"
-
-#ifdef MYSQL_NO_SHORT_NAMES
-#include "undef_short"
-#endif

DELETED sqlplusint/stream2string1.hh
Index: sqlplusint/stream2string1.hh
==================================================================
--- sqlplusint/stream2string1.hh
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef __stream2string1_hh__
-#define __stream2string1_hh__
-
-template<class Strng, class T>
-Strng stream2string(const T &object);
-
-#endif

DELETED sqlplusint/stream2string2.hh
Index: sqlplusint/stream2string2.hh
==================================================================
--- sqlplusint/stream2string2.hh
+++ /dev/null
@@ -1,2 +0,0 @@
-
-#include "stream2string1.hh"

DELETED sqlplusint/stream2string3.hh
Index: sqlplusint/stream2string3.hh
==================================================================
--- sqlplusint/stream2string3.hh
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef __stream2string3_hh__
-#define __stream2string3_hh__
-
-#include <strstream.h>
-
-template<class Strng, class T>
-Strng stream2string(const T &object) {
-  ostrstream str;
-  object.out_stream(str);
-  str << ends;
-  Strng s = str.str();
-#ifdef __USLC__
-  strstreambuf *tmpbuf = str.rdbuf();
-  tmpbuf->freeze(0);
-#else
-  str.freeze(0);
-#endif
-  return s;
-}
-
-#endif

DELETED sqlplusint/tiny_int1.hh
Index: sqlplusint/tiny_int1.hh
==================================================================
--- sqlplusint/tiny_int1.hh
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef __tiny_int1_hh__
-#define __tiny_int1_hh__
-
-class tiny_int {
-  char value;
-public:
-  tiny_int() {}
-  tiny_int(short int v) : value(v) {}
-  operator short int() const {return (short int)value;};
-  tiny_int &operator = (short int v) {value=v; return *this;}
-  tiny_int &operator += (short int v) {value+=v; return *this;}
-  tiny_int &operator -= (short int v) {value-=v; return *this;}
-  tiny_int &operator *= (short int v) {value*=v; return *this;}
-  tiny_int &operator /= (short int v) {value/=v; return *this;}
-  tiny_int &operator %= (short int v) {value%=v; return *this;}
-  tiny_int &operator &= (short int v) {value&=v; return *this;}
-  tiny_int &operator |= (short int v) {value|=v; return *this;}
-  tiny_int &operator ^= (short int v) {value^=v; return *this;}
-  tiny_int &operator <<= (short int v) {value<<=v; return *this;}
-  tiny_int &operator >>= (short int v) {value>>=v; return *this;}
-  tiny_int &operator ++ () {value++; return *this;}
-  tiny_int &operator -- () {value--; return *this;}
-  tiny_int operator ++ (int) {tiny_int tmp=value; value++; return tmp;}
-  tiny_int operator -- (int) {tiny_int tmp=value; value--; return tmp;}
-  tiny_int operator - (const tiny_int& i) const {return value - i;}
-  tiny_int operator + (const tiny_int& i) const {return value + i;}
-  tiny_int operator * (const tiny_int& i) const {return value * i;}
-  tiny_int operator / (const tiny_int& i) const {return value / i;}
-  tiny_int operator % (const tiny_int& i) const {return value % i;}
-  tiny_int operator | (const tiny_int& i) const {return value | i;}
-  tiny_int operator & (const tiny_int& i) const {return value & i;}
-  tiny_int operator ^ (const tiny_int& i) const {return value ^ i;}
-  tiny_int operator << (const tiny_int& i) const {return value << i;}
-  tiny_int operator >> (const tiny_int& i) const {return value >> i;}
-};
-
-
-#endif

DELETED sqlplusint/tiny_int2.hh
Index: sqlplusint/tiny_int2.hh
==================================================================
--- sqlplusint/tiny_int2.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "tiny_int1.hh"
-

DELETED sqlplusint/tiny_int3.hh
Index: sqlplusint/tiny_int3.hh
==================================================================
--- sqlplusint/tiny_int3.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "tiny_int2.hh"
-

DELETED sqlplusint/tracker.h
Index: sqlplusint/tracker.h
==================================================================
--- sqlplusint/tracker.h
+++ /dev/null
@@ -1,25 +0,0 @@
-
-#ifndef __mysql_tracker_h__
-#define __mysql_tracker_h__
-
-#include <set.h>
-#include <map.h>
-
-template <class Pointer, class Object> 
-class pointer_tracker {
-private:
-  map<Pointer*, set<Object*> > tracker;
-public:
-  void insert (Pointer *p, Object *o) {
-    tracker[p].insert(o);
-  }
-  void remove (Pointer *p, Object *o) {
-    tracker[p].erase(o); 
-    if (tracker[p].empty()) {
-      tracker.erase(p);
-      o->purge(p);
-    }
-  }
-};
-
-#endif

DELETED sqlplusint/type_info.cc
Index: sqlplusint/type_info.cc
==================================================================
--- sqlplusint/type_info.cc
+++ /dev/null
@@ -1,132 +0,0 @@
-#ifdef __WIN32__
-#include <Windows32/Base.h>
-#include <Windows32/Defines.h>
-#include <Windows32/Structures.h>
-#include <winsock.h>
-#endif
-#include <mysql.h>
-#include <string.h>
-#include "datetime1.hh"
-#include "set1.hh"
-#include "type_info3.hh"
-
-typedef string Enum;
-
-const mysql_type_info::sql_type_info mysql_type_info::types[62] = {
-  sql_type_info("DECIMAL NOT NULL", typeid(double), 0),
-  sql_type_info("TINYINT NOT NULL", typeid(signed char), 1, true),
-  sql_type_info("SMALLINT NOT NULL", typeid(short int), 2, true),
-  sql_type_info("INT NOT NULL", typeid(int), 3, true),
-  sql_type_info("FLOAT NOT NULL", typeid(float), 4, true),
-  sql_type_info("DOUBLE NOT NULL", typeid(double), 5, true),
-  sql_type_info("NULL NOT NULL", typeid(void), 6),
-  sql_type_info("TIMESTAMP NOT NULL", typeid(Time), 7),
-  sql_type_info("BIGINT NOT NULL", typeid(long long int), 8, true),
-  sql_type_info("MEDIUMINT NOT NULL", typeid(int), 9),
-  sql_type_info("DATE NOT NULL", typeid(Date), 10, true),
-  sql_type_info("TIME NOT NULL", typeid(Time), 11, true),
-  sql_type_info("DATETIME NOT NULL", typeid(DateTime), 12, true),
-  sql_type_info("ENUM NOT NULL", typeid(Enum), 13, true),
-  sql_type_info("SET NOT NULL", typeid(Set<string>), 14, true),
-  sql_type_info("TINYBLOB NOT NULL", typeid(string), 15),
-  sql_type_info("MEDIUMBLOB NOT NULL", typeid(string), 16),
-  sql_type_info("LONGBLOB NOT NULL", typeid(string), 17),
-  sql_type_info("BLOB NOT NULL", typeid(string), 18),
-  sql_type_info("VARCHAR NOT NULL", typeid(string), 19, true),
-  sql_type_info("CHAR NOT NULL", typeid(string), 20),
-
-  sql_type_info(),
-  sql_type_info("TINYINT UNSIGNED NOT NULL", typeid(unsigned char), 22, true),
-  sql_type_info("SMALLINT UNSIGNED NOT NULL", typeid(unsigned short int), 23, true),
-  sql_type_info("INT UNSIGNED NOT NULL", typeid(unsigned int), 24, true),
-  sql_type_info(),
-  sql_type_info(),
-  sql_type_info(),
-  sql_type_info(),
-  sql_type_info("BIGINT UNSIGNED NOT NULL", typeid(unsigned long long int), 29, true),
-  sql_type_info("MEDIUMINT UNSIGNED NOT NULL", typeid(unsigned int), 30),
-
-  sql_type_info("DECIMAL NULL", typeid(Null<double>), 0),
-  sql_type_info("TINYINT NULL", typeid(Null<signed char>), 1, true),
-  sql_type_info("SMALLINT NULL", typeid(Null<short int>), 2, true),
-  sql_type_info("INT NULL", typeid(Null<int>), 3, true),
-  sql_type_info("FLOAT NULL", typeid(Null<float>), 4, true),
-  sql_type_info("DOUBLE NULL", typeid(Null<double>), 5, true),
-  sql_type_info("NULL NULL", typeid(Null<void>), 6),
-  sql_type_info("TIMESTAMP NULL", typeid(Null<Time>), 7),
-  sql_type_info("BIGINT NULL", typeid(Null<long long int>), 8, true),
-  sql_type_info("MEDIUMINT NULL", typeid(Null<int>), 9), 
-  sql_type_info("DATE NULL", typeid(Null<Date>), 10, true),
-  sql_type_info("TIME NULL", typeid(Null<Time>), 11, true),
-  sql_type_info("DATETIME NULL", typeid(Null<DateTime>), 12, true),
-  sql_type_info("ENUM NULL", typeid(Null<Enum>), 13, true),
-  sql_type_info("SET NULL", typeid(Null<Set<string> >), 14, true),
-  sql_type_info("TINYBLOB NULL", typeid(Null<string>), 15),
-  sql_type_info("MEDIUMBLOB NULL", typeid(Null<string>), 16),
-  sql_type_info("LONGBLOB NULL", typeid(Null<string>), 17),
-  sql_type_info("BLOB NULL", typeid(Null<string>), 18),
-  sql_type_info("VARCHAR NULL", typeid(Null<string>), 19, true),
-  sql_type_info("CHAR NULL", typeid(Null<string>), 20),
-
-  sql_type_info(),
-  sql_type_info("TINYINT UNSIGNED NULL", typeid(Null<unsigned char>), 22, true),
-  sql_type_info("SMALLINT UNSIGNED NULL", typeid(Null<unsigned short int>),23, true),
-  sql_type_info("INT UNSIGNED NULL", typeid(Null<unsigned int>), 24, true),
-  sql_type_info(),
-  sql_type_info(),
-  sql_type_info(),
-  sql_type_info(),
-  sql_type_info("BIGINT UNSIGNED NULL", typeid(Null<unsigned long long int>),29, true),
-  sql_type_info("MEDIUMINT UNSIGNED NULL", typeid(Null<unsigned int>), 30),
-};
-
-const mysql_type_info::sql_type_info_lookup 
-  mysql_type_info::lookups(mysql_type_info::types, 62);
-
-mysql_ti_sql_type_info_lookup::
-mysql_ti_sql_type_info_lookup(const sql_type_info types[], const int size) {
-  for (int i = 0; i != size; i++) {
-    if (types[i]._default)
-      _map[types[i]._c_type] = i;
-  }
-}
-
-unsigned char mysql_type_info::type(enum_field_types t, 
-			              bool _unsigned, bool _null) {
-  if (_null) {
-    if (_unsigned) {
-      return unsigned_null_offset + t;
-    } else {
-      if (t < 200) return null_offset + t;
-      else return null_offset + (t-234);
-    }
-  } else {
-    if (_unsigned) {
-      return unsigned_offset + t;
-    } else {
-      if (t < 200) return offset + t;
-      else return offset + (t-234);
-    }
-  }
-}
-
-bool mysql_type_info::quote_q() const {
-  if (base_type().c_type() == typeid(string) ||
-      base_type().c_type() == typeid(Date) ||
-      base_type().c_type() == typeid(Time) ||
-      base_type().c_type() == typeid(DateTime) ||
-      base_type().c_type() == typeid(Enum) ||
-      base_type().c_type() == typeid(Set<string>)) 
-    {
-      return true;
-    } else {
-      return false;
-    }
-}
-
-bool mysql_type_info::escape_q() const {
-  if (c_type() == typeid(string)) 
-    return true;
-  else 
-    return false;
-}

DELETED sqlplusint/type_info1.hh
Index: sqlplusint/type_info1.hh
==================================================================
--- sqlplusint/type_info1.hh
+++ /dev/null
@@ -1,183 +0,0 @@
-#ifndef __type_info1_hh__
-#define __type_info1_hh__
-#ifdef __WIN32__
-#include <Windows32/Base.h>
-#include <Windows32/Defines.h>
-#include <Windows32/Structures.h>
-#include <winsock.h>
-#define errno WSAGetLastError()
-#endif
-#include <mysql.h>
-#include <typeinfo>
-#include <map>
-
-#ifdef __USLC__
-using namespace std;
-#endif
-
-class mysql_type_info;
-class mysql_ti_sql_type_info_lookup;
-
-class mysql_ti_sql_type_info {
-  friend mysql_type_info;
-  friend mysql_ti_sql_type_info_lookup;
-private:
-  const char          *_sql_name;
-  const type_info     *_c_type;
-  const unsigned char  _base_type;
-  const bool           _default;
-  mysql_ti_sql_type_info (const mysql_ti_sql_type_info &b);           // can't do
-  mysql_ti_sql_type_info& operator=(const mysql_ti_sql_type_info &b); //  "    "
-  mysql_ti_sql_type_info () {} 
-  // OEP - didn't init _base_type and _default mysql_ti_sql_type_info () {} 
-  // all private, only mysql_type_info can
-  // create because there *must* be only one copy
-  // of each.
-  mysql_ti_sql_type_info (const char *s, const type_info &t, 
-			  const unsigned char bt = 0, const bool d = false)
-    : _sql_name(s), _c_type(&t), _base_type(bt), _default(d) {}
-};
-
-struct type_info_cmp {
-  bool operator() (const type_info *lhs, const type_info *rhs) const {
-    return lhs->before(*rhs);
-  }
-};
-
-class mysql_ti_sql_type_info_lookup {
-  friend mysql_type_info;
-private:
-  typedef mysql_ti_sql_type_info sql_type_info;
-
-  map<const type_info *, unsigned char, type_info_cmp> _map;
-  
-  mysql_ti_sql_type_info_lookup(const sql_type_info types[], const int size);
-
-  const unsigned char& operator [] (const type_info &ti) const {
-    return _map.find(&ti)->second;
-  }
-};
-
-//: Class that holds basic type information for ColData.
-class mysql_type_info {
-private:
-  typedef mysql_ti_sql_type_info sql_type_info;
-  typedef mysql_ti_sql_type_info_lookup sql_type_info_lookup;
-private:
-  static const sql_type_info types[62];
-  
-  static const unsigned char offset = 0;
-  static const unsigned char unsigned_offset = 21; 
-  static const unsigned char null_offset = 31;
-  static const unsigned char unsigned_null_offset = 52;
-
-  static const sql_type_info_lookup lookups;
-  
-  static unsigned char type(enum_field_types t,
-			      bool _unsigned, bool _null = false);
-public:
-  static const unsigned char string_type = 20;
-private:
-  unsigned char num;
-  inline const sql_type_info& deref() const;
-public:
-  //!dummy: static const unsigned char string_type;
-  //: The id of the string type.
-  mysql_type_info() {} //:
-  mysql_type_info(unsigned char n) : num(n) {} //:
-  inline mysql_type_info(enum_field_types t,
-			 bool _unsigned, bool _null);
-  //:
-  inline mysql_type_info(const MYSQL_FIELD &f);
-  //:
-  mysql_type_info(const mysql_type_info &t) : num(t.num) {}
-  //:
-  mysql_type_info(const type_info &t) {num = lookups[t]; }
-  //: 
-  mysql_type_info& operator = (unsigned char n) {num=n; return *this;}
-  //:
-  mysql_type_info& operator = (const mysql_type_info &t) 
-    {num = t.num; return *this;}
-  //:
-  mysql_type_info& operator = (const type_info &t)
-    {num = lookups[t]; return *this;}
-  //:
-  inline const char*           name()      const;
-  //: Returns a implication defined name of the c++ type.
-  // Returns the name that would be returned by typeid().name() for the C++ type
-  // associated with the sql type.
-  inline const char*           sql_name()  const;
-  //: Returns the name for the sql type.
-  inline const type_info&      c_type()    const;
-  //: Returns the type_info for the C++ type associated with the sql type.
-  inline const mysql_type_info base_type() const;
-  //: Returns the type_info for the C++ type inside of the Null type.
-  // If the type is not null then this is the same as c_type() 
-         int                   id()        const {return num;}
-  //: Returns the id of the sql_type.
-  // Note: Do not ever use this id directly as it may change between versions.
-
-  bool quote_q()  const;
-  //: Returns true if the sql type is of a type that needs to be quoted.
-  bool escape_q() const;
-  //: Returns true if the sql type is of a type that needs to be escaped.
-  
-  bool before(mysql_type_info &b) { return num < b.num; }
-  //: Provides ordering
-  // You can also use id() for the same purpose.
-};
-
-inline const mysql_type_info::sql_type_info& mysql_type_info::deref() const {
-  return types[num];
-}
-inline const char*           mysql_type_info::name()      const {
-  return deref()._c_type->name();
-}
-inline const char*           mysql_type_info::sql_name()  const {
-  return deref()._sql_name;
-}
-inline const type_info&      mysql_type_info::c_type()    const {
-  return *deref()._c_type;
-}
-inline const mysql_type_info mysql_type_info::base_type() const 
-{
-  return mysql_type_info(deref()._base_type);
-}
-
-inline mysql_type_info::mysql_type_info(enum_field_types t,
-					bool _unsigned, bool _null) {
-  num = type(t,_unsigned,_null);
-}
-
-inline mysql_type_info::mysql_type_info(const MYSQL_FIELD &f) {
-  num = type(f.type, (f.flags & UNSIGNED_FLAG), !(f.flags & NOT_NULL_FLAG));
-}
-
-inline bool operator == (const mysql_type_info& a, const mysql_type_info& b) {
-  return a.id() == b.id();
-}
-
-inline bool operator != (const mysql_type_info& a, const mysql_type_info& b) {
-  return a.id() != b.id();
-}
-
-inline bool operator == (const type_info &a, const mysql_type_info &b) {
-  return a == b.c_type();
-}
-
-inline bool operator != (const type_info &a, const mysql_type_info &b) {
-  return a != b.c_type();
-}
-
-inline bool operator == (const mysql_type_info &a, const type_info &b) {
-  return a.c_type() == b;
-}
-
-inline bool operator != (const mysql_type_info &a, const type_info &b) {
-  return a.c_type() != b;
-}
-
-
-#endif
-
-

DELETED sqlplusint/type_info2.hh
Index: sqlplusint/type_info2.hh
==================================================================
--- sqlplusint/type_info2.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "type_info1.hh"
-

DELETED sqlplusint/type_info3.hh
Index: sqlplusint/type_info3.hh
==================================================================
--- sqlplusint/type_info3.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "type_info2.hh"
-

DELETED sqlplusint/vallist.cc
Index: sqlplusint/vallist.cc
==================================================================
--- sqlplusint/vallist.cc
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "vallist3.hh"
-#include "row2.hh"
-
-void create_vector(int size, vector<bool>& v, bool t0, 
-		   bool t1, bool t2, bool t3, bool t4,
-		   bool t5, bool t6, bool t7, bool t8,
-		   bool t9, bool ta, bool tb, bool tc)
-{
-  v.reserve(size);
-  v.push_back(t0); if (size == 1) return;
-  v.push_back(t1); if (size == 2) return;
-  v.push_back(t2); if (size == 3) return;
-  v.push_back(t3); if (size == 4) return;
-  v.push_back(t4); if (size == 5) return;
-  v.push_back(t5); if (size == 6) return;
-  v.push_back(t6); if (size == 7) return;
-  v.push_back(t7); if (size == 8) return;
-  v.push_back(t8); if (size == 9) return;
-  v.push_back(t9); if (size == 10) return;
-  v.push_back(ta); if (size == 11) return;
-  v.push_back(tb); if (size == 12) return;
-  v.push_back(tc);
-}
-
-template <class Container>
-void create_vector(const Container&c, vector<bool>&v, string s0, string s1, 
-		   string s2, string s3, string s4, string s5, string s6,
-		   string s7, string s8, string s9, string sa, string sb,
-		   string sc)
-{
-  v.insert(v.begin(), c.size(), false);
-  v[c.parent().field_num(s0)] = true; if (s1.empty()) return;
-  v[c.parent().field_num(s1)] = true; if (s2.empty()) return;
-  v[c.parent().field_num(s2)] = true; if (s3.empty()) return;
-  v[c.parent().field_num(s3)] = true; if (s4.empty()) return;
-  v[c.parent().field_num(s4)] = true; if (s5.empty()) return;
-  v[c.parent().field_num(s5)] = true; if (s6.empty()) return;
-  v[c.parent().field_num(s6)] = true; if (s7.empty()) return;
-  v[c.parent().field_num(s7)] = true; if (s8.empty()) return;
-  v[c.parent().field_num(s8)] = true; if (s9.empty()) return;
-  v[c.parent().field_num(s9)] = true; if (sa.empty()) return;
-  v[c.parent().field_num(sa)] = true; if (sb.empty()) return;
-  v[c.parent().field_num(sb)] = true; if (sc.empty()) return;
-  v[c.parent().field_num(sc)] = true;
-}
-
-template void create_vector (const Row &c, vector<bool>&v, string s0, string s1, 
-		   string s2, string s3, string s4, string s5, string s6,
-		   string s7, string s8, string s9, string sa, string sb,
-		   string sc);
-
-template void create_vector (const MutableRow<ResUse> &c, vector<bool>&v, string s0, string s1, 
-		   string s2, string s3, string s4, string s5, string s6,
-		   string s7, string s8, string s9, string sa, string sb,
-		   string sc);
-
-template void create_vector (const MutableRow<MutableRes> &c, vector<bool>&v, string s0, string s1, 
-		   string s2, string s3, string s4, string s5, string s6,
-		   string s7, string s8, string s9, string sa, string sb,
-		   string sc);
-
-/*
-int main() {
-  const char *x[8] = {"12","11","This is a", "9","7","6","5","4"};
-  cout << "Compile Good\n";
-  simp_list_b<const char **> X(x,x+8);
-  cout << *X.begin() << endl;
-  cout << value_list(X) << endl;
-  cout << value_list(X,";") << endl;
-  vector<char *> xx;
-  xx.push_back("testing");
-  xx.push_back("I want you now");
-  xx.push_back("Whats the deal man");
-  cout << value_list(xx,",",quote) << endl;
-  cout << value_list(xx,";") << endl;
-  vector<const char *> xy;
-  xy.push_back("test");
-  xy.push_back("want");
-  xy.push_back("deal");
-  cout << "V1: " << value_list(xy,",",quote,true,false,true) << endl;
-  cout << "V2: " << value_list(xy,",",quote,true,true,true) << endl;
-  cout << "V3: " << value_list(xy,";") << endl;
-  cout << "EL: " << equal_list(xy,xx) << endl;
-  cout << "EL: " << equal_list(xy,xx, " AND ", " > ", quote,true,false,true) << endl;
-}
-*/

DELETED sqlplusint/vallist1.hh
Index: sqlplusint/vallist1.hh
==================================================================
--- sqlplusint/vallist1.hh
+++ /dev/null
@@ -1,286 +0,0 @@
-#ifndef __vallist1_hh__
-#define __vallist1_hh__
-
-#include <string>
-#include <vector>
-#include "manip1.hh"
-
-template <class Seq, class Manip>
-struct value_list_b {
-  const Seq          *list;
-  const vector<bool> fields;
-  const char         *delem;
-  Manip              manip;
-  value_list_b(const Seq &s, const vector<bool> &f, const char *d, Manip m) 
-    : list(&s), fields(f), delem(d), manip(m) {}
-};
-
-template <class Seq1, class Seq2, class Manip>
-struct equal_list_b {
-  const Seq1         *list1;
-  const Seq2         *list2;
-  const vector<bool> fields;
-  const char         *delem;
-  const char         *equl;
-  Manip              manip;
-  equal_list_b(const Seq1 &s1, const Seq2 &s2, const vector<bool> &f,
-	       const char *d, const char *e, Manip m) 
-    : list1(&s1), list2(&s2), fields(f), delem(d), equl(e), manip(m) {}
-};
-
-template <class Seq, class Manip>
-struct value_list_ba {
-  const Seq          *list;
-  const char         *delem;
-  Manip              manip;
-  value_list_ba(const Seq &s, const char* d, Manip m) 
-    : list(&s), delem(d), manip(m) {}
-};
-
-template <class Seq1, class Seq2, class Manip>
-struct equal_list_ba {
-  const Seq1         *list1;
-  const Seq2         *list2;
-  const char         *delem;
-  const char         *equl;
-  Manip              manip;
-  equal_list_ba(const Seq1 &s1, const Seq2 &s2, const char *d, const char *e,
-		Manip m) 
-    : list1(&s1), list2(&s2), delem(d), equl(e), manip(m) {}
-};
-
-//
-
-template <class Seq, class Manip>
-ostream& operator << (ostream &o, const value_list_b<Seq, Manip> &cl) {
-  typename Seq::const_iterator i =  cl.list->begin();
-  register int k = 0;
-  for (;;) {
-    if (cl.fields[k])
-      o << cl.manip << *i;
-    k++;
-    if (++i == cl.list->end()) break;
-    if (cl.fields[k])
-      o << cl.delem;
-  }
-  return o;
-}
-
-template <class Seq1, class Seq2, class Manip>
-ostream& operator << (ostream &o, const equal_list_b<Seq1, Seq2, Manip> &el) {
-  typename Seq1::const_iterator i = el.list1->begin();
-  typename Seq2::const_iterator j = el.list2->begin();
-  register int k = 0;
-  for (;;) {
-    if (el.fields[k]) 
-      o << *i << el.equl << el.manip << *j;
-    k++;
-    j++;
-    if (++i == el.list1->end()) break;
-    if (el.fields[k])
-      o << el.delem;
-  }
-  return o;
-}
-
-template <class Seq, class Manip>
-ostream& operator << (ostream &o, const value_list_ba<Seq, Manip> &cl) {
-  typename Seq::const_iterator i =  cl.list->begin();
-  for (;;) {
-    o << cl.manip << *i;
-    if (++i == cl.list->end()) break;
-    o << cl.delem;
-  }
-  return o;
-}
-
-template <class Seq1, class Seq2, class Manip>
-ostream& operator << (ostream &o, const equal_list_ba<Seq1, Seq2, Manip> &el) {
-  typename Seq1::const_iterator i = el.list1->begin();
-  typename Seq2::const_iterator j = el.list2->begin();
-  for (;;) {
-    o << *i << el.equl << el.manip << *j;
-    j++;
-    if (++i == el.list1->end()) break;
-    o << el.delem;
-  }
-  return o;
-}
-
-template <class Iter>
-class simp_list_b {
-public:
-  Iter _begin;
-  Iter _end;
-public:
-  typedef Iter const_iterator;
-  simp_list_b(Iter b, Iter e) : _begin(b), _end(e) {}
-  Iter begin() const {return _begin;}
-  Iter end() const {return _end;}
-};
-
-//
-// create vector
-//
-
-void create_vector(int size, vector<bool>& v, bool t0, 
-		   bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-		   bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-		   bool t9=false, bool ta=false, bool tb=false, bool tc=false);
-
-template <class Container>
-void create_vector(const Container&c, vector<bool>&v, string s0, string s1, 
-		   string s2, string s3, string s4, string s5, string s6,
-		   string s7, string s8, string s9, string sa, string sb,
-		   string sc);
-
-//
-// value list
-//
-
-template <class Seq>  
-inline
-value_list_ba<Seq,do_nothing_type0> 
-value_list(const Seq &s, const char *d = ",") {
-  return value_list_ba<Seq ,do_nothing_type0> (s, d, do_nothing);
-}
-
-template <class Seq, class Manip>  
-inline
-value_list_ba<Seq,Manip> 
-value_list(const Seq &s, const char *d, Manip m) {
-  return value_list_ba<Seq,Manip> (s, d, m);
-}
-
-template <class Seq, class Manip>
-inline
-value_list_b<Seq,Manip>
-value_list(const Seq &s, const char *d, Manip m, const vector<bool> &vb)
-{
-  return value_list_b<Seq, Manip>(s, vb, d, m);
-}
-
-template <class Seq, class Manip>
-value_list_b<Seq,Manip>
-value_list(const Seq &s, const char *d, Manip m, bool t0, 
-	   bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	   bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	   bool t9=false, bool ta=false, bool tb=false, bool tc=false)
-{
-  vector<bool> vb;
-  create_vector(s.size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-  return value_list_b<Seq, Manip>(s, vb, d, m);
-}
-
-template <class Seq>
-value_list_b<Seq,do_nothing_type0>
-value_list(const Seq &s, const char *d, bool t0, 
-	   bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	   bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	   bool t9=false, bool ta=false, bool tb=false, bool tc=false)
-{
-  vector<bool> vb;
-  create_vector(s.size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-  return value_list_b<Seq, do_nothing_type0> (s, vb, d, do_nothing);
-}
-
-template <class Seq>
-value_list_b<Seq,do_nothing_type0>
-value_list(const Seq &s, bool t0, 
-	   bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	   bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	   bool t9=false, bool ta=false, bool tb=false, bool tc=false)
-{
-  vector<bool> vb;
-  create_vector(s.size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-  return value_list_b<Seq, do_nothing_type0> (s, vb, ",",do_nothing);
-}
-
-//
-// equal list
-//
-
-template <class Seq1, class Seq2>  
-inline
-equal_list_ba<Seq1,Seq2,do_nothing_type0> 
-equal_list(const Seq1 &s1, const Seq2 &s2, const char *d = ",", 
-	   const char *e = " = ") {
-  return equal_list_ba<Seq1,Seq2,do_nothing_type0> (s1, s2, d, e, do_nothing);
-}
-
-template <class Seq1, class Seq2, class Manip>
-inline
-equal_list_ba<Seq1,Seq2,Manip> 
-equal_list(const Seq1 &s1, const Seq2 &s2, 
-	   const char *d, const char *e, Manip m) {
-  return equal_list_ba<Seq1,Seq2,Manip> (s1, s2, d, e, m);
-}
-
-template <class Seq1, class Seq2, class Manip>
-inline
-equal_list_b<Seq1, Seq2, Manip>
-equal_list(const Seq1 &s1, const Seq2 &s2, const char *d, const char *e, 
-	   Manip m, const vector<bool> &vb)
-{
-  return equal_list_b<Seq1,Seq2,Manip>(s1, s2, vb, d, e, m);
-}
-
-// complete
-template <class Seq1, class Seq2, class Manip>
-equal_list_b<Seq1, Seq2, Manip>
-equal_list(const Seq1 &s1, const Seq2 &s2, const char *d, const char *e, 
-	   Manip m, bool t0, 
-	   bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	   bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	   bool t9=false, bool ta=false, bool tb=false, bool tc=false)
-{
-  vector<bool> vb;
-  create_vector(s1.size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-  return equal_list_b<Seq1,Seq2,Manip>(s1, s2, vb, d, e, m);
-}
-
-// delem, equl
-template <class Seq1, class Seq2>
-equal_list_b<Seq1, Seq2, do_nothing_type0>
-equal_list(const Seq1 &s1, const Seq2 &s2, const char *d, const char *e, 
-	   bool t0, 
-	   bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	   bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	   bool t9=false, bool ta=false, bool tb=false, bool tc=false)
-{
-  vector<bool> vb;
-  create_vector(s1.size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-  return equal_list_b<Seq1,Seq2,do_nothing_type0>
-    (s1, s2, vb, d, e, do_nothing);
-}
-
-// delem
-template <class Seq1, class Seq2>
-equal_list_b<Seq1,Seq2,do_nothing_type0>
-equal_list(const Seq1 &s1, const Seq2 &s2, const char *d, bool t0, 
-	   bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	   bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	   bool t9=false, bool ta=false, bool tb=false, bool tc=false)
-{
-  vector<bool> vb;
-  create_vector(s1.size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-  return equal_list_b<Seq1,Seq2,do_nothing_type0> 
-    (s1, s2, vb, d, " = ", do_nothing);
-}
-
-// nothing
-template <class Seq1, class Seq2>
-equal_list_b<Seq1,Seq2,do_nothing_type0>
-equal_list(const Seq1 &s1, const Seq2 &s2, bool t0, 
-	   bool t1=false, bool t2=false, bool t3=false, bool t4=false,
-	   bool t5=false, bool t6=false, bool t7=false, bool t8=false,
-	   bool t9=false, bool ta=false, bool tb=false, bool tc=false)
-{
-  vector<bool> vb;
-  create_vector(s1.size(), vb, t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,ta,tb,tc);
-  return equal_list_b<Seq1,Seq2,do_nothing_type0> 
-    (s1, s2, vb,"," ," = " ,do_nothing);
-}
-
-#endif
-

DELETED sqlplusint/vallist2.hh
Index: sqlplusint/vallist2.hh
==================================================================
--- sqlplusint/vallist2.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "vallist1.hh"
-

DELETED sqlplusint/vallist3.hh
Index: sqlplusint/vallist3.hh
==================================================================
--- sqlplusint/vallist3.hh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-#include "vallist2.hh"
-

ADDED   test/cpool.cpp
Index: test/cpool.cpp
==================================================================
--- /dev/null
+++ test/cpool.cpp
@@ -0,0 +1,105 @@
+/***********************************************************************
+ test/cpool.cpp - Tests the ConnectionPool class.
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc. and
+ (c) 2007 by Jonathan Wakely.  Others may also hold copyrights on
+ code in this file.  See the CREDITS file in the top directory of
+ the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <cpool.h>
+#include <connection.h>
+
+#include <iostream>
+
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+#	define SLEEP(n) Sleep((n) * 1000)
+#else
+#	include <unistd.h>
+#	define SLEEP(n) sleep(n)
+#endif
+
+using namespace std;
+
+class TestConnection : public mysqlpp::Connection
+{
+public:
+	TestConnection() : itime_(time(0)) { }
+	time_t instantiation_time() const { return itime_; }
+
+private:
+	time_t itime_;
+};
+
+
+class TestConnectionPool : public mysqlpp::ConnectionPool
+{
+public:
+    ~TestConnectionPool() { clear(); }
+
+    unsigned int max_idle_time() { return 1; }
+
+private:
+    TestConnection* create() { return new TestConnection; }
+    void destroy(mysqlpp::Connection* cp) { delete cp; }
+};
+
+
+int
+main()
+{
+	TestConnectionPool pool;
+
+	mysqlpp::Connection* conn1 = pool.grab();
+	mysqlpp::Connection* conn2 = pool.grab();
+	if (conn1 == conn2) {
+		cerr << "Pool returned the same connection twice!" << endl;
+		return 1;
+	}
+
+	pool.release(conn2);
+	mysqlpp::Connection* conn3 = pool.grab();
+	if (conn2 != conn3) {
+		cerr << "conn2 should have been reused but wasn't!" << endl;
+		return 1;
+	}
+
+	time_t itime_c1 = dynamic_cast<TestConnection*>(conn1)->
+			instantiation_time();
+	pool.release(conn1);
+	SLEEP(pool.max_idle_time() + 1);
+	mysqlpp::Connection* conn4 = pool.grab();
+	time_t itime_c4 = dynamic_cast<TestConnection*>(conn4)->
+			instantiation_time();
+	if (itime_c1 == itime_c4) {
+		cerr << "conn1 should have been destroyed but wasn't!" << endl;
+		return 1;
+	}
+
+	pool.release(conn3);
+	pool.release(conn4);
+	pool.shrink();
+	if (!pool.empty()) {
+		cerr << "Shrunken pool is not empty!" << endl;
+		return 1;
+	}
+
+	return 0;
+}

ADDED   test/datetime.cpp
Index: test/datetime.cpp
==================================================================
--- /dev/null
+++ test/datetime.cpp
@@ -0,0 +1,214 @@
+/***********************************************************************
+ test/datetime.cpp - Tests the Date, DateTime, and Time classes.
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include <stdio.h>
+
+using namespace mysqlpp;
+using namespace std;
+
+
+// Compare the given string against the object inserted into a Query stream.
+template <class T>
+static unsigned int
+test_query_insert(const T& object, const char* expected, 
+		const char* what)
+{
+	Query q = Connection().query();	// don't do this in real code
+	q << object;
+	if (q.str().compare(expected) == 0) {
+		cout << what << " is '" << expected <<
+				"' in Query, as expected." << endl;
+		return 0;
+	}
+	else {
+		cerr << what << " '" << object << "' should be '" <<
+				expected << "' when inserted into Query!" << endl;
+		return 1;
+	}
+}
+
+
+// Compare the given string against the object inserted into an ostream.
+template <class T>
+static unsigned int
+test_ostream_insert(const T& object, const char* expected, 
+		const char* what)
+{
+	ostringstream os;
+	os << object;
+	if (os.str().compare(expected) == 0) {
+		cout << what << " is '" << expected <<
+				"' in ostream, as expected." << endl;
+		return 0;
+	}
+	else {
+		cerr << what << " '" << object << "' should be '" <<
+				expected << "' when inserted into ostream!" << endl;
+		return 1;
+	}
+}
+
+
+// Compare the given string against the return value of the object's
+// str() method.
+template <class T>
+static unsigned int
+test_str_method(const T& object, const char* expected, const char* what)
+{
+	if (object.str().compare(expected) == 0) {
+		cout << what << ".str() returns '" << expected <<
+				"', as expected." << endl;
+		return 0;
+	}
+	else {
+		cerr << what << " '" << object << "' should return '" <<
+				expected << "' from str() method!" << endl;
+		return 1;
+	}
+}
+
+
+// Compare the given string against the object when cast to std::string
+template <class T>
+static unsigned int
+test_string_operator(const T& object, const char* expected, 
+		const char* what)
+{
+	if (string(object).compare(expected) == 0) {
+		cout << "string(" << what << ") is '" << expected <<
+				"', as expected." << endl;
+		return 0;
+	}
+	else {
+		cerr << what << " '" << object << "' should be '" <<
+				expected << "' when cast to std::string!" << endl;
+		return 1;
+	}
+}
+
+
+// Compare the given string against the object when converted in several
+// different ways to a string.
+template <class T>
+static unsigned int
+test_stringization(const T& object, const char* expected, 
+		const char* what)
+{
+	return	test_query_insert(object, expected, what) +
+			test_ostream_insert(object, expected, what) +
+			test_string_operator(object, expected, what) +
+			test_str_method(object, expected, what);
+}
+
+
+// Given a Date and a set of values we should expect to be in it,
+// compare its outputs against values we compute separately.
+static unsigned int
+test_date(const Date& d, int year, int month, int day)
+{
+	if (	d.year() == year && 
+			d.month() == month && 
+			d.day() == day) {
+		char ac[20];
+		snprintf(ac, sizeof(ac), "%04d-%02d-%02d",
+				year, month, day);
+		return test_stringization(d, ac, "Date");
+	}
+	else {
+		cerr << "Date '" << d << "' values should be '" <<
+				year << '-' << month << '-' << day << endl;
+		return 1;
+	}
+}
+
+
+// Given a Time and a set of values we should expect to be in it,
+// compare its outputs against values we compute separately.
+static unsigned int
+test_time(const Time& t, int hour, int minute, int second)
+{
+	if (	t.hour() == hour && 
+			t.minute() == minute && 
+			t.second() == second) {
+		char ac[20];
+		snprintf(ac, sizeof(ac), "%02d:%02d:%02d",
+				hour, minute, second);
+		return test_stringization(t, ac, "Time");
+	}
+	else {
+		cerr << "Time '" << t << "' values should be '" <<
+				hour << ':' << minute << ':' << second << endl;
+		return 1;
+	}
+}
+
+
+// Given a DateTime and a set of values we should expect to be in it,
+// compare its outputs against values we compute separately.
+static unsigned int
+test_datetime(const DateTime& dt,
+		int year, int month, int day,
+		int hour, int minute, int second)
+{
+	return	test_date(Date(dt), year, month, day) +
+			test_time(Time(dt), hour, minute, second);
+}
+
+
+// Run tests above for the various types we support using the date and
+// time values given.
+static unsigned int
+test(int year, int month, int day, int hour, int minute, int second)
+{
+	unsigned int failures = 0;
+	failures += test_date(Date(year, month, day), year, month, day);
+	failures += test_datetime(
+			DateTime(year, month, day, hour, minute, second),
+			year, month, day, hour, minute, second);
+	failures += test_time(Time(hour, minute, second), hour, minute,
+			second);
+	return failures;
+}
+
+
+int
+main()
+{
+	unsigned int failures = 0;
+	failures += test(0, 0, 0, 0, 0, 0);
+	failures += test(1, 2, 3, 4, 5, 6);
+	failures += test_stringization(DateTime(), "NOW()", "DateTime");
+	DateTime dt;
+	dt.year(2007);
+	failures += test_stringization(dt, "2007-00-00 00:00:00", "DateTime");
+	return failures;
+}
+

ADDED   test/inttypes.cpp
Index: test/inttypes.cpp
==================================================================
--- /dev/null
+++ test/inttypes.cpp
@@ -0,0 +1,78 @@
+/***********************************************************************
+ test/inttypes.cpp - Tests whether the integer typedef equivalents for
+    SQL types in lib/sql_types.h are correct on this system.  If not,
+	you need to change either that file, lib/common.h, or both.
+
+ Copyright (c) 2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <sql_types.h>
+
+#include <iostream>
+
+template <typename IntType>
+static bool
+test_size(const char* desc, IntType value, size_t expected_size)
+{
+	size_t actual_size = sizeof(value);
+	if (actual_size == expected_size) {
+		return true;
+	}
+	else {
+		std::cerr << desc << " is sized incorrectly on this "
+				"platform:" << std::endl << "\t" << actual_size <<
+				" bytes, not " << expected_size << " as expected." <<
+				std::endl;
+		return false;
+	}
+}
+
+
+int
+main(int, char* argv[])
+{
+	int failures = 0;
+
+	failures += test_size("sql_tinyint",
+			mysqlpp::sql_tinyint(0), 1) == false;
+	failures += test_size("sql_tinyint_unsigned",
+			mysqlpp::sql_tinyint_unsigned(0), 1) == false;
+	failures += test_size("sql_smallint",
+			mysqlpp::sql_smallint(0), 2) == false;
+	failures += test_size("sql_smallint_unsigned",
+			mysqlpp::sql_smallint_unsigned(0), 2) == false;
+	failures += test_size("sql_mediumint",
+			mysqlpp::sql_mediumint(0), 4) == false;
+	failures += test_size("sql_mediumint_unsigned",
+			mysqlpp::sql_mediumint_unsigned(0), 4) == false;
+	failures += test_size("sql_int",
+			mysqlpp::sql_int(0), 4) == false;
+	failures += test_size("sql_int_unsigned",
+			mysqlpp::sql_int_unsigned(0), 4) == false;
+	failures += test_size("sql_bigint",
+			mysqlpp::sql_bigint(0), 8) == false;
+	failures += test_size("sql_bigint_unsigned",
+			mysqlpp::sql_bigint_unsigned(0), 8) == false;
+	
+	return failures;
+}
+

ADDED   test/manip.cpp
Index: test/manip.cpp
==================================================================
--- /dev/null
+++ test/manip.cpp
@@ -0,0 +1,153 @@
+/***********************************************************************
+ test/manip.cpp - Tests the quoting and escaping manipulators.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+
+template <class T>
+static bool
+is_quoted(const std::string& s, T orig_str, size_t orig_len)
+{
+	return (s.length() == (orig_len + 2)) &&
+			(s.at(0) == '\'') &&
+			(s.at(orig_len + 1) == '\'') &&
+			(s.compare(1, orig_len, orig_str) == 0);
+}
+
+
+template <class T>
+static bool
+is_quoted(const std::string& s, mysqlpp::Null<T> orig_str, size_t orig_len)
+{
+	return is_quoted(s, orig_str.data, orig_len);
+}
+
+
+// Stringish types should be quoted when inserted into Query when an
+// explicit quote manipulator is used.
+template <class T>
+static bool
+explicit_query_quote(T test, size_t len)
+{
+	mysqlpp::Query q(0);
+	q << mysqlpp::quote << test;
+	if (is_quoted(q.str(), test, len)) {
+		return true;
+	}
+	else {
+		std::cerr << "Explicit quote of " << typeid(test).name() <<
+				" in Query failed: " << q.str() << std::endl;
+		return false;
+	}
+}
+
+
+// Nothing should be quoted when inserted into an ostream, even when an
+// explicit quote manipulator is used.  The manipulators are only for
+// use with Query streams.
+template <class T>
+static bool
+no_explicit_ostream_quote(T test, size_t len)
+{
+	std::ostringstream outs;
+	outs << mysqlpp::quote << test;
+	if (!is_quoted(outs.str(), test, len)) {
+		return true;
+	}
+	else {
+		std::cerr << "Explicit quote of " << typeid(test).name() <<
+				" in ostream erroneously honored!" << std::endl;
+		return false;
+	}
+}
+
+
+// Nothing should be implicitly quoted as of v3.  We used to do it for
+// mysqlpp::String (formerly ColData) when inserted into Query, but
+// that's a silly edge case.  The only time end-user code should be
+// using Strings to build queries via the Query stream interface is when
+// using BLOBs or when turning result set data back around in a new
+// query.  In each case, there's no reason for String to behave
+// differently from std::string, which has always had to be explicitly
+// quoted.
+template <class T>
+static bool
+no_implicit_quote(T test, size_t len)
+{
+	std::ostringstream outs;
+	outs << test;
+	if (!is_quoted(outs.str(), test, len)) {
+		mysqlpp::Query q(0);
+		q << test;
+		if (!is_quoted(q.str(), test, len)) {
+			return true;
+		}
+		else {
+			std::cerr << typeid(test).name() << " erroneously implicitly "
+					"quoted in Query: " << outs.str() <<
+					std::endl;
+			return false;
+		}
+	}
+	else {
+		std::cerr << typeid(test).name() << " erroneously implicitly "
+				"quoted in ostringstream: " << outs.str() <<
+				std::endl;
+		return false;
+	}
+}
+
+
+// Run all tests above for the given type
+template <class T>
+static bool
+test(T test, size_t len)
+{
+	return explicit_query_quote(test, len) &&
+			no_explicit_ostream_quote(test, len) &&
+			no_implicit_quote(test, len);
+}
+
+
+int
+main()
+{
+	char s[] = "Doodle me, James, doodle me!";
+	const size_t len = strlen(s);
+
+	int failures = 0;
+	failures += test(s, len) == false;
+	failures += test(static_cast<char*>(s), len) == false;
+	failures += test(static_cast<const char*>(s), len) == false;
+	failures += test(std::string(s), len) == false;
+	failures += test(mysqlpp::SQLTypeAdapter(s), len) == false;
+	failures += test(mysqlpp::Null<std::string>(s), len) == false;
+	return failures;
+}
+

ADDED   test/null_comparison.cpp
Index: test/null_comparison.cpp
==================================================================
--- /dev/null
+++ test/null_comparison.cpp
@@ -0,0 +1,68 @@
+/***********************************************************************
+ test/null_comparison.cpp - Tests that Null<T> and null_type comparison
+ 	operators and SSQLS comparison functions work correctly.
+
+ Copyright (c) 2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+#include <ssqls.h>
+
+#include <iostream>
+
+sql_create_1(ssqls, 1, 0,
+		mysqlpp::Null<int>, a_column);
+
+int
+main()
+{
+	mysqlpp::Null<int> null_int = mysqlpp::null;
+	mysqlpp::Null<int> non_null_int = 42;
+	if (	!(null_int == non_null_int) &&
+			(null_int != non_null_int) &&
+			(null_int < non_null_int) &&
+			!(non_null_int == null_int) &&
+			(non_null_int != null_int) &&
+			!(non_null_int < null_int) &&
+			(null_int == mysqlpp::null) &&
+			!(null_int != mysqlpp::null) &&
+			(non_null_int != mysqlpp::null) &&
+			!(non_null_int == mysqlpp::null) &&
+			(mysqlpp::sql_cmp(null_int, null_int) == 0) &&
+			(mysqlpp::sql_cmp(null_int, non_null_int) < 0) &&
+			(mysqlpp::sql_cmp(non_null_int, null_int) > 0)) {
+		ssqls foo(null_int), bar(non_null_int);
+		if ((foo < bar) && (foo != bar) && !(bar < foo) && !(foo == bar)) {
+			return 0;
+		}
+		else {
+			std::cerr << "SSQLS comparison gave unexpected result" <<
+					std::endl;
+			return 1;
+		}
+	}
+	else {
+		std::cerr << "Null comparison gave unexpected result" << std::endl;
+		return 1;
+	}
+}
+

ADDED   test/null_uniqueness.cpp
Index: test/null_uniqueness.cpp
==================================================================
--- /dev/null
+++ test/null_uniqueness.cpp
@@ -0,0 +1,39 @@
+/***********************************************************************
+ test/null_uniqueness.cpp - Code for checking that null_type cannot be
+    converted to anything else.  Because it triggers a compile-time
+	check, it can't be included in the test suite.  You have to just
+	try building it.  Comment out the assignment to int to check that
+	the return statement also triggers the compile-time check.
+
+ Copyright (c) 2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+
+int
+main()
+{
+	mysqlpp::Null<int> ni = mysqlpp::null;
+	int this_should_not_even_compile = mysqlpp::null;
+	return ni;		// neither should this
+}
+

ADDED   test/qssqls.cpp
Index: test/qssqls.cpp
==================================================================
--- /dev/null
+++ test/qssqls.cpp
@@ -0,0 +1,76 @@
+/***********************************************************************
+ test/qssqls.cpp - Tests SQL query creation from SSQLS in Query.
+
+ Copyright (c) 2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+#include <ssqls.h>
+
+#include <iostream>
+
+using namespace mysqlpp;
+using namespace std;
+
+
+// Don't use any stringish types here.  That will cause code below to
+// eventually try to call DBDriver::escape_string() through the
+// Connection object, which we don't really have, so it asplodes.
+sql_create_17(test,
+	17, 0,
+	sql_tinyint,			tinyint_v,
+	sql_tinyint_unsigned,	tinyint_unsigned_v,
+	sql_smallint,			smallint_v,
+	sql_smallint_unsigned,	smallint_unsigned_v,
+	sql_int,				int_v,
+	sql_int_unsigned,		int_unsigned_v,
+	sql_mediumint,			mediumint_v,
+	sql_mediumint_unsigned, mediumint_unsigned_v,
+	sql_bigint,				bigint_v,
+	sql_bigint_unsigned,	bigint_unsigned_v,
+	sql_float,				float_v,
+	sql_double,				double_v,
+	sql_decimal,			decimal_v,
+	sql_bool,				bool_v,
+	sql_date,				date_v,
+	sql_time,				time_v,
+	sql_datetime,			datetime_v);
+
+int
+main()
+{
+	Query q = Connection().query();		// don't do this in real code
+	test empty(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, false,
+			Date(), Time(), DateTime());
+	test filled(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11.0, 12.0, 13.0,
+			bool(14), Date("1515-15-15"), Time("16:16:16"),
+			DateTime("1717-17-17 17:17:17"));
+
+	cout << q.insert(empty) << endl << endl;
+	cout << q.insert(filled) << endl << endl;
+	cout << q.replace(empty) << endl << endl;
+	cout << q.replace(filled) << endl << endl;
+	cout << q.update(filled, empty) << endl << endl;
+
+	return 0;
+}
+

ADDED   test/qstream.cpp
Index: test/qstream.cpp
==================================================================
--- /dev/null
+++ test/qstream.cpp
@@ -0,0 +1,79 @@
+/***********************************************************************
+ test/qstream.cpp - Tests insertion of all officially-supported data
+	types into a Query stream, plus some that aren't official.  Failure
+	is defined as an exception being thrown for any one of these.
+
+ Copyright (c) 2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+
+#include <iostream>
+
+using namespace mysqlpp;
+
+int
+main()
+{
+	try {
+		// If you're reading this for implicit recommendations of good
+		// code style, please ignore the hack-job on the following line.
+		mysqlpp::Query q = mysqlpp::Connection().query();
+
+		// Throw everything we can think of at Query's stream interface.
+		// Don't do this in real code, either.
+		q << 	sql_tinyint(0) << sql_tinyint_unsigned(0) <<
+				sql_smallint(0) << sql_smallint_unsigned(0) <<
+				sql_mediumint(0) << sql_mediumint_unsigned(0) <<
+				sql_int(0) << sql_int_unsigned(0) << long(0) <<
+				sql_bigint(0) << sql_bigint_unsigned(0) << longlong(0) <<
+				sql_int1(0) << sql_int2(0) << sql_int3(0) <<
+				sql_int4(0) << sql_int8(0) << sql_middleint(0) <<
+				sql_float(0) << sql_double(0) << sql_decimal(0) <<
+				sql_numeric(0) <<
+				sql_fixed(0) << sql_float4(0) << sql_float8(0) <<
+				sql_bool(false) << sql_boolean(false) << bool(false) <<
+				sql_enum() <<
+				sql_char() << sql_varchar() << sql_long_varchar() <<
+				sql_character_varying() << sql_long() <<
+				sql_tinytext() << sql_text() <<
+				sql_mediumtext() << sql_longtext() <<
+				sql_blob() << sql_tinyblob() << sql_mediumblob() <<
+				sql_longblob() << sql_long_varbinary() <<
+				sql_date() << sql_time() << sql_datetime() <<
+				sql_timestamp() <<
+				sql_set();
+		std::cout << q << std::endl;
+		return 0;
+	}
+	catch (const mysqlpp::TypeLookupFailed& e) {
+		std::cerr << "Query stream insert failed: " << e.what() <<
+				std::endl;
+		return 1;
+	}
+	catch (const std::exception& e) {
+		std::cerr << "Unexpected exception: " << e.what() <<
+				std::endl;
+		return 1;
+	}
+}
+

ADDED   test/string.cpp
Index: test/string.cpp
==================================================================
--- /dev/null
+++ test/string.cpp
@@ -0,0 +1,310 @@
+/***********************************************************************
+ test/string.cpp - Tests the behavior of mysqlpp::String, particularly
+	its data conversion methods.
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+
+#include <iostream>
+
+
+// Does an equality comparison on the value, forcing the string to
+// convert itself to T on the way.  Note that we do this test in terms
+// of greater and less than to avoid pedantic GCC warnings for the
+// floating point type tests.
+template <typename T>
+static bool
+test_equality(const mysqlpp::String& s, T value)
+{
+	T converted = s.conv(value);
+	if ((value < converted) || (value > converted)) {
+		std::cerr << "Type conversion to " << typeid(T).name() <<
+				" failed: \"" << s << "\" != \"" << value << "\"." <<
+				std::endl;
+		return false;
+	}
+	else {
+		return true;
+	}
+}
+
+
+// Check that we can convert strings with decimals in them to native
+// floating-point values, regardless of locale.
+static bool
+test_float_conversion()
+{
+	// This stuff should just work
+	if (!test_equality(mysqlpp::String("123.00"), 123)) return false;
+	if (!test_equality(mysqlpp::String("123."), 123)) return false;
+
+	// This is trickier: MySQL ignores the system locale when it comes
+	// to decimal separators, always using '.', so ensure the conversion
+	// stuff in MySQL++ does the right thing regardless.  Test against
+	// this system's current locale, an arbitrary European one where ','
+	// is the decimal separator, and the "C" locale where it's '.'.
+	if (!test_equality(mysqlpp::String("621.200"), 621.2)) return false;
+	std::locale old_locale = std::locale::global(std::locale::classic());
+	if (!test_equality(mysqlpp::String("621.200"), 621.2)) return false;
+	try {
+		std::locale::global(std::locale("de_DE"));
+		if (!test_equality(mysqlpp::String("621.200"), 621.2)) return false;
+	}
+	catch (std::runtime_error& e) {
+		std::cerr << "WARNING: skipping European locale string "
+				"conversion test:" << std::endl;
+		std::cerr << "\t" << e.what() << std::endl;
+	}
+	std::locale::global(old_locale);
+
+	// Check that we choke on silly float-like values
+	try {
+		if (test_equality(mysqlpp::String("621.20.0"), 621.2)) {
+			std::cerr << "Quasi-FP with two decimal points "
+					"converting without error!" << std::endl;
+		}
+		return false;
+	}
+	catch (const mysqlpp::BadConversion&) {
+		return true;
+	}
+}
+
+
+// Tries to convert the given string to an int.  Returns false if we got
+// a BadConversion exception and didn't expect it, or didn't get one we
+// expected.  Returns false on all other exceptions regardless.
+static bool
+test_int_conversion(const mysqlpp::String& s, bool throw_expected)
+{
+	// Try the conversion
+	bool conv_threw = false;
+	try {
+		int converted = s;
+		(void)converted;	// pedantic warning squisher
+	}
+	catch (const mysqlpp::BadConversion&) {
+		conv_threw = true;
+	}
+	catch (const std::exception& e) {
+		std::cerr << "Unexpected " << typeid(e).name() <<
+				" exception in test_int_conv: " << e.what() << std::endl;
+		return false;
+	}
+	catch (...) {
+		std::cerr << "Like, totally bogus exception in test_int_conv, "
+				"man!" << std::endl;
+		return false;
+	}
+
+	// Did it do what we expected?
+	if (throw_expected == conv_threw) {
+		return true;
+	}
+	else {
+		std::cerr << "Conversion of \"" << s << "\" to int " <<
+				(conv_threw ? "did not throw" : "threw") << "; " <<
+				(throw_expected ? "did not expect" : "expected") <<
+				" it to." << std::endl;
+		return false;
+	}
+}
+
+
+// Checks that String's null comparison methods work right
+static bool
+test_null()
+{
+	mysqlpp::String not_null("", mysqlpp::mysql_type_info::string_type, false);
+	mysqlpp::String is_null("", mysqlpp::mysql_type_info::string_type, true);
+	if (not_null.is_null() == true) {
+		std::cerr << "not_null.is_null() == true!" << std::endl;
+		return false;
+	}
+	else if (not_null == mysqlpp::null) {
+		std::cerr << "not_null == mysqlpp:null!" << std::endl;
+		return false;
+	}
+	else if (is_null.is_null() == false) {
+		std::cerr << "is_null.is_null() == false!" << std::endl;
+		return false;
+	}
+	else if (is_null != mysqlpp::null) {
+		std::cerr << "is_null != mysqlpp:null!" << std::endl;
+		return false;
+	}
+	else {
+		return true;
+	}
+}
+
+
+// Ensures numeric conversions of many different types get handled
+// correctly.
+static bool
+test_numeric(const mysqlpp::String& s, int value)
+{
+	return	test_equality(s, static_cast<signed char>(value)) &&
+			test_equality(s, static_cast<unsigned char>(value)) &&
+			test_equality(s, static_cast<signed short>(value)) &&
+			test_equality(s, static_cast<unsigned short>(value)) &&
+			test_equality(s, static_cast<signed int>(value)) &&
+			test_equality(s, static_cast<unsigned int>(value)) &&
+			test_equality(s, static_cast<signed long>(value)) &&
+			test_equality(s, static_cast<unsigned long>(value)) &&
+#if !defined(NO_LONG_LONGS)
+			test_equality(s, static_cast<mysqlpp::longlong>(value)) &&
+			test_equality(s, static_cast<mysqlpp::ulonglong>(value)) &&
+#endif
+			test_equality(s, static_cast<float>(value)) &&
+			test_equality(s, static_cast<double>(value));
+}
+
+
+static bool
+test_quote_q(const mysqlpp::String& s, bool expected)
+{
+	if (s.quote_q() == expected) {
+		return true;
+	}
+	else {
+		std::cerr << s.type().name() << " should" <<
+				(expected ? "" : " NOT") << " be quoted." << std::endl;
+		return false;
+	}
+}
+
+
+// Similar to test_equality, but only works with std::string
+// comparisons, which uses String::operator ==()
+static bool
+test_string_equality(const mysqlpp::String& s, std::string value)
+{
+	if (s == value) {
+		if (s != value) {
+			std::cerr << "String(\"" << s << "\") != std::string(\"" <<
+					value << "\"), case 2!" << std::endl;
+			return false;
+		}
+		else {
+			return true;
+		}
+	}
+	else {
+		std::cerr << "String(\"" << s << "\") != std::string(\"" <<
+				value << "\"), case 1!" << std::endl;
+		return false;
+	}
+}
+
+
+// Same as above, but for two String objects
+static bool
+test_string_equality(const mysqlpp::String& s1,
+		const mysqlpp::String s2)
+{
+	if (s1 == s2) {
+		return true;
+	}
+	else {
+		std::cerr << "String(\"" << s1 << "\") != String(\"" <<
+				s2 << "\"), but should be equal!" << std::endl;
+		return false;
+	}
+}
+
+
+// Inverse of above.
+static bool
+test_string_inequality(const mysqlpp::String& s1,
+		const mysqlpp::String& s2)
+{
+	if (s1 != s2) {
+		return true;
+	}
+	else {
+		std::cerr << "String(\"" << s1 << "\") == String(\"" <<
+				s2 << "\") but shouldn't be!" << std::endl;
+		return false;
+	}
+}
+
+
+int
+main(int, char* argv[])
+{
+	try {
+		int failures = 0;
+		mysqlpp::String definit;
+		mysqlpp::String empty("");
+		mysqlpp::String zero("0");
+		mysqlpp::String nonzero("42");
+		mysqlpp::String intable1("42.");
+		mysqlpp::String intable2("42.0");
+		mysqlpp::String nonint("42.1");
+
+		failures += test_equality(definit, mysqlpp::Date()) == false;
+		failures += test_equality(definit, 
+				mysqlpp::DateTime(0, 0, 0, 0, 0, 0)) == false;
+		failures += test_equality(definit, mysqlpp::Time()) == false;
+		failures += test_equality(definit, false) == false;
+		failures += test_equality(nonzero, true) == false;
+		failures += test_numeric(definit, 0) == false;
+		failures += test_numeric(zero, 0) == false;
+		failures += test_numeric(nonzero, 42) == false;
+		failures += test_quote_q(definit, true) == false;
+		failures += test_quote_q(mysqlpp::String("1", typeid(int)),
+				false) == false;
+		failures += test_float_conversion() == false;
+		failures += test_float_conversion() == false;
+		failures += test_int_conversion(definit, false) == false;
+		failures += test_int_conversion(zero, false) == false;
+		failures += test_int_conversion(nonzero, false) == false;
+		failures += test_int_conversion(intable1, false) == false;
+		failures += test_int_conversion(intable2, false) == false;
+		failures += test_int_conversion(nonint, true) == false;
+		failures += test_null() == false;
+		failures += test_string_equality(definit, empty) == false;
+		failures += test_string_equality(empty, definit) == false;
+		failures += test_string_equality(definit, "") == false;
+		failures += test_string_equality(zero, "0") == false;
+		failures += test_string_inequality(definit, zero) == false;
+		failures += test_string_inequality(zero, definit) == false;
+		failures += test_string_inequality(empty, nonzero) == false;
+		
+		return failures;
+	}
+	catch (mysqlpp::Exception& e) {
+		std::cerr << "Unexpected MySQL++ exception caught in " <<
+				argv[0] << ": " << e.what() << std::endl;
+		return 1;
+	}
+	catch (std::exception& e) {
+		std::cerr << "Unexpected C++ exception caught in " <<
+				argv[0] << ": " << e.what() << std::endl;
+		return 1;
+	}
+
+}
+

ADDED   test/tcp.cpp
Index: test/tcp.cpp
==================================================================
--- /dev/null
+++ test/tcp.cpp
@@ -0,0 +1,111 @@
+/***********************************************************************
+ test/tcp.cpp - Tests the address parser/verifier in TCPConnection.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <exceptions.h>
+#include <tcp_connection.h>
+
+#include <iostream>
+#include <sstream>
+
+
+static void
+test(const char* addr_svc, unsigned int port, const char* exp_addr,
+		unsigned int exp_port)
+{
+	std::string addr(addr_svc), error;
+
+	mysqlpp::TCPConnection::parse_address(addr, port, error);
+	if (error.size()) {
+		throw mysqlpp::SelfTestFailed("TCP address parse error: " +
+				error);
+	}
+	else if (addr.compare(exp_addr) != 0) {
+		std::ostringstream outs;
+		outs << "TCP address parse mismatch: '" << addr << "' != '" <<
+				exp_addr << "'";
+		throw mysqlpp::SelfTestFailed(outs.str());
+	}
+	else if (port != exp_port) {
+		std::ostringstream outs;
+		outs << "TCP port parse mismatch: '" << port << "' != '" <<
+				exp_port << "'";
+		throw mysqlpp::SelfTestFailed(outs.str());
+	}
+}
+
+
+static void
+fail(const char* addr_svc, unsigned int port, const char* exp_addr,
+		unsigned int exp_port)
+{
+	try {
+		test(addr_svc, port, exp_addr, exp_port);
+	}
+	catch (...) {
+		return;		// eat expected error
+	}
+
+	std::ostringstream outs;
+	outs << "'" << addr_svc << "' == ('" << exp_addr <<
+			"', " << exp_port << ") but should not.";
+	throw mysqlpp::SelfTestFailed(outs.str());
+}
+
+
+int
+main()
+{
+	try {
+		// Domain name and IPv4 literal tests
+		test(":", 0, "", 0);
+		test("1.2.3.4", 0, "1.2.3.4", 0);
+		test("1.2.3.4:", 0, "1.2.3.4", 0);
+		test("1.2.3.4:567", 0, "1.2.3.4", 567);
+		test("1.2.3.4", 890, "1.2.3.4", 890);
+		test("1.2.3.4:telnet", 0, "1.2.3.4", 23);
+		test("a.b.com", 0, "a.b.com", 0);
+		test("a.b.com", 987, "a.b.com", 987);
+		fail("@", 0, "@", 0);
+		fail("::", 0, "", 0);
+		fail(":", 0, "1.2.3.4", 45);
+		fail("a.b.com::", 0, "a.b.com", 0);
+		fail("a.b:com:1", 0, "a.b.com", 1);
+
+		// IPv6 literal tests
+		test("[]:123", 0, "", 123);
+		test("[::]:telnet", 0, "::", 23);
+
+		std::cout << "TCP address parsing passed." << std::endl;
+		return 0;
+	}
+	catch (mysqlpp::SelfTestFailed& e) {
+		std::cerr << "TCP address parse error: " << e.what() << std::endl;
+		return 1;
+	}
+	catch (std::exception& e) {
+		std::cerr << "Unexpected test failure: " << e.what() << std::endl;
+		return 2;
+	}
+}

ADDED   test/uds.cpp
Index: test/uds.cpp
==================================================================
--- /dev/null
+++ test/uds.cpp
@@ -0,0 +1,154 @@
+/***********************************************************************
+ test/uds.cpp - Tests the Unix domain socket verifier in
+ 	UnixDomainSocketConnection.  This test always succeeds on Windows!
+
+ Copyright (c) 2007-2008 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <connection.h>
+#include <exceptions.h>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#if !defined(MYSQLPP_PLATFORM_WINDOWS)
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <errno.h>
+
+static const char* success_path = "test_uds_success.sock";
+static const char* failure_path = "test_uds_failure.sock";
+
+static int
+make_socket(const char* path, mode_t mode)
+{
+	// Just in case a socket with this name exists already, try to
+	// remove it.  Only a failure if it exists and we can't remove it.
+	if ((unlink(path) < 0) && (errno != ENOENT)) {
+		return -1;
+	}
+
+	// Create the domain socket
+	int fd = socket(AF_LOCAL, SOCK_STREAM, 0);
+	if (fd < 0) {
+		return -1;
+	}
+	
+	// Bind the socket to the named file
+	struct sockaddr_un sun;
+	memset(&sun, 0, sizeof(sun));
+	sun.sun_family = AF_LOCAL;
+	strncpy(sun.sun_path, path, sizeof(sun.sun_path));
+	sun.sun_path[sizeof(sun.sun_path) - 1] = '\0';
+	if (bind(fd, reinterpret_cast<sockaddr*>(&sun), sizeof(sun)) < 0) {
+		return -1;
+	}
+
+	// Change the socket's mode as requested
+	if (chmod(path, mode) < 0) {
+		return -1;
+	}
+
+	return fd;
+}
+
+	
+static void
+test_success()
+{
+	std::string error;
+	int fd = make_socket(success_path, S_IREAD | S_IWRITE);
+	if (fd >= 0) {
+		bool fail = !mysqlpp::UnixDomainSocketConnection::is_socket(
+				success_path, &error);
+		if (fail) {
+			throw mysqlpp::SelfTestFailed(error);
+		}
+	}
+	else {
+		std::ostringstream outs;
+		outs << "Failed to create test domain socket: " << strerror(errno);
+		throw mysqlpp::SelfTestFailed(outs.str());
+	}
+}
+
+
+static void
+test_failure()
+{
+	int fd = make_socket(failure_path, S_IREAD);
+	if (fd < 0) {
+		std::ostringstream outs;
+		outs << "Failed to create test domain socket: " << strerror(errno);
+		throw mysqlpp::SelfTestFailed(outs.str());
+	}
+
+	if (mysqlpp::UnixDomainSocketConnection::is_socket(failure_path)) {
+		throw mysqlpp::SelfTestFailed("Failed to fail on read-only socket");
+	}
+	else if (mysqlpp::UnixDomainSocketConnection::is_socket(
+			"BogusBogus.sock")) {
+		throw mysqlpp::SelfTestFailed("Failed to fail on bad file name");
+	}
+	else {
+		close(fd);
+		unlink(failure_path);
+		fd = creat(failure_path, S_IREAD | S_IWRITE);
+		bool success = mysqlpp::UnixDomainSocketConnection::is_socket(
+				failure_path);
+		if (success) {
+			throw mysqlpp::SelfTestFailed("Failed to fail on non-socket");
+		}
+	}
+}
+#endif
+
+
+int
+main()
+{
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+	// Test not appropriate to this platform.  Always succeed.
+	return 0;
+#else
+	try {
+		test_success();
+		unlink(success_path);
+		test_failure();
+		unlink(failure_path);
+		return 0;
+	}
+	catch (mysqlpp::SelfTestFailed& e) {
+		std::cerr << "TCP address parse error: " << e.what() << std::endl;
+		return 1;
+	}
+	catch (std::exception& e) {
+		std::cerr << "Unexpected test failure: " << e.what() << std::endl;
+		return 2;
+	}
+#endif
+}

ADDED   test/wnp.cpp
Index: test/wnp.cpp
==================================================================
--- /dev/null
+++ test/wnp.cpp
@@ -0,0 +1,55 @@
+/***********************************************************************
+ test/wnp.cpp - Tests WindowsNamedPipeConnection::is_wnp().  This test
+ 	can only fail on Windows!  It succeeds when built for anything else.
+
+ Copyright (c) 2007 by Educational Technology Resources, Inc.
+ Others may also hold copyrights on code in this file.  See the
+ CREDITS file in the top directory of the distribution for details.
+
+ This file is part of MySQL++.
+
+ MySQL++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ MySQL++ is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with MySQL++; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ USA
+***********************************************************************/
+
+#include <mysql++.h>
+
+#include <iostream>
+#include <sstream>
+
+
+int
+main()
+{
+#if defined(MYSQLPP_PLATFORM_WINDOWS)
+	if (!mysqlpp::WindowsNamedPipeConnection::is_wnp(".")) {
+		std::cerr << "Failed to identify Windows named pipe" << std::endl;
+	
+	}
+	else if (mysqlpp::WindowsNamedPipeConnection::is_wnp("bogus")) {
+		std::cerr << "Failed to fail for bogus named pipe" << std::endl;
+	}
+	else if (mysqlpp::WindowsNamedPipeConnection::is_wnp(0)) {
+		std::cerr << "Failed to fail for null named pipe" << std::endl;
+	}
+	else {
+		return 0;
+	}
+
+	return 1;
+#else
+	return 0;
+#endif
+}

ADDED   updexdll.bat
Index: updexdll.bat
==================================================================
--- /dev/null
+++ updexdll.bat
@@ -0,0 +1,5 @@
+@echo off
+rem This copies the built MySQL++ DLL into the Windows-specific
+rem examples' build directories so they can run without hackery.
+copy debug\*.dll examples\vstudio\debug > NUL
+copy release\*.dll examples\vstudio\release > NUL