<?xml version="1.0" ?>
<bakefile-gen>
    <input>
        ./mysql++.bkl
    </input>

    <!-- List of output formats to generate: -->
    <add-formats>
        autoconf,msvc6prj,mingw
    </add-formats>

    <add-flags formats="mingw">
        -o$(INPUT_FILE_DIR)/Makefile.mingw
    </add-flags>
</bakefile-gen>

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.

/usr/share/automake/COPYING
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.

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.

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.
	Also, if there were a "steering committee" for MySQL++, he'd be
	on it.

	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 multiquery example 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.


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.

2.3.2, 2007.07.11 (r1669)

2000-01-06  Dale Hawkins  <dhawkins@cdrgts.com>
	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.

	* acconfig.h: New file.  Lets me define the library versioning.
	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.

	* autogen.sh: Boilerplate configuration jump-start script.
    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.

2000-01-04  Dale Hawkins  <dhawkins@cdrgts.com>
    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)

	* sqlplus.spec.in (Packager): Created new spec.in file to work
    o Fixed the new localtime() alternative selection code
      for VS2003 and various uses of STLport.

	with autoconf/automake and libtool for easier releases of
    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.

	RPMs. (Yes, I am a Linux bigot and I think the world should
    o Fixed a bug in the Connection copy ctor where it didn't
      completely initialize the object.

	revolve around RPMs).
    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)

	* configure.in: Reworked this file to work with spec.in and
    o MinGW and Cygwin will now build and link to mysqlpp DLLs.

	support libtool type versioning.
    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.

1999-10-15 Sinisa Milivojevic <sinisa@cytanet.com.cy>
    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/userman/html/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.

* Changed version to 1.2					 
    o Fixed some compiler warnings in custom*.h.  Thanks to Chris Frey
      for this patch.

* First offical release. Version 1.0 and 1.1 were releases by Sinisa
    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.

  before I (Kevin Atkinson) made him the offical maintainer,
    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.

* Many manual fixes.
    o PDF version of user manual now has hard page breaks between
      chapters.

* Changed README and Changelog
    o Removed complic1 example.  Wasn't pulling its own weight.
      Everything it is supposed to demonstrate is shown in other
      examples already.

* Changed source to be compilable by gcc 2.95.xx, tribute to Kevin
    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.

  Atkinson <kevinatk@home.com>
    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.

* Added methods in Connection class which are necessary for
    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.)

  fullfilling administrative functions with MySQL
    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.

* Added many bug fixes in code pertaining to missing class
    o Every declaration in MySQL++ is now documented in the reference
      manual, or explicitly treated as "internal only".

  initializers , as notified by Michael Rendell <michael@cs.mun.ca>
    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.

* Sinisa Milivojevic <sinisa@cytanet.com.cy> is now the offical
    o Improved a lot of existing reference manual documentation while
      adding the new stuff.

  maintainer.
    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.

1999-08-02  Sinisa Milivojevic <sinisa@cytanet.com.cy>
    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).

* Changed version to 1.1
    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.

* Added several bug fixes
    o Once again, the main include file was renamed, this time to
      mysql++.h.  Hopefully this is the last renaming!

* Fixed memory leak problems and variables overlapping problems.
    o mysql++.hh still exists.  It emits a compiler warning that the
      file is obsolete, then it #includes mysql++.h for you.

* Added automake and autoconf support by loic@net.fr
    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.

* Added Makefile for manual
    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++.

* Added support for cygwin
    o There is now only one place where conditional inclusion of
      winsock.h happens: platform.h.

* Added example sinisa_ex (let modesty prevail) which used to crash a 
    o Beautified the example programs.


  lot when memory allocation, memory leak and overlap problems were
  present. Smooth running of this example proves that all those bugs are
1.7.19, 2004.10.25 (r186)

	fixed
    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.
     
* Changed manual
    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.)

* Cheanged README
    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.

* Many other smaller things
    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.)


1999-06-09  Michael Widenius  <monty@monty.pp.sci.fi>
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 version to 1.0
    * 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
* 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.

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.


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 [host] [user] [pass]

    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 a dtest
    run, 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 Bakefiles and Autoconf Files
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    If you're on a Unixy platform and change any of mysql++.bkl,
    configure.ac, or config/*, you must re-run the bootstrap script
    to regenerate the build files.  The bootstrap script also has
    other functions:

        $ ./bootstrap [pedantic] [no{doc,ex,lib,opt}] [configure flags]

    If you pass 'pedantic' to the bootstrap script, it will set up
    the autoconf build system so it turns on all of GCC's warnings and
    such.  It's useful to build the library in this mode when making
    changes to make sure there are no obvious problems with the code.

    If you pass '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 broken.

    If you pass 'noex', the generated Makefiles and project files
    won't try to build any of the examples.

    If you pass 'nolib', the generated Makefiles and project files
    won't try to build the MySQL++ library.

    If you pass 'noopt', compiler optimization will be turned off
    on systems that use configure.  (It currently has no effect on
    MinGW or Visual C++.)

    You can pass any of the previous options in any order.  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 for more on
    configure script options.

    If you're on Windows and you change the Bakefile (mysql++.bkl),
    re-generating the Makefiles and project files from it is a
    little tricky.  The above procedure doesn't work because the
    native Win32 port of Bakefile is incomplete, and Bakefile doesn't
    build correctly under Cygwin.  Therefore, you need to run the
    bakefile program directly.  You'll use one of these two commands,
    depending on which compiler you're using:

        C:\> bakefile -f msvc6prj mysql++.bkl
        C:\> bakefile -f mingw -o Makefile.mingw mysql++.bkl


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

The installation procedure depends on the compiler you use to build
MySQL++.  See:

/usr/share/automake/INSTALL
	README.unix -   for Unix, Linux, Mac OS X, etc.
	README.cygwin - for Cygwin
	README.mingw -  for MinGW
	README.vc -     for Visual C++

Also see the main README file for things that apply to all systems.

		  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!

		  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!

# This includes sqlplus.spec _and_ sqlplus.spec.in 
#   (this way rpm -ta xxxx work)
EXTRA_DIST = @PACKAGE@.spec @PACKAGE@.spec.in @PACKAGE@-config.in

SUBDIRS = sqlplusint examples doc # devel

bin_SCRIPTS = sqlplus-config

CONFIG_FILE = @PACKAGE@-config-@SQLPLUS_MAJOR_VERSION@.@SQLPLUS_MINOR_VERSION@

$(CONFIG_FILE): @PACKAGE@-config
	cp $^ $@

@PACKAGE@-config: @PACKAGE@-config.in

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
This is C++ API  library for MySQL.

	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.
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
	Its home page is http://tangentsoft.net/mysql++/
continue to keep mysql++ library under LGPL.


Prerequisites
~~~~~~~~~~~~~
	To build MySQL++, you must have the MySQL C API development
	files installed.
Original information from kevinatk@home.com:
---------------------------------------------------------------------

	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".
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.

	If you're building on Windows with Visual C++ or MinGW, you
	need to install the native Win32 port of MySQL from mysql.com.
To my knowledge this library requiures gcc 2.8 or egcc or better and of
course the mysql library.
	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.

To compile the library and modify the file Configure aproprietly
and type make.

Additional Things to Read
I am working on trying to get this to compile into a library.
~~~~~~~~~~~~~~~~~~~~~~~~~
	Each major platform we support has a dedicated README.* file
	for it containing information specific to that platform.
	Please read it.

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 authorship information, see the CREDITS file.

	For license information, see the LICENSE file.
For more information please see the manual.

	If you want to change MySQL++, see the HACKERS file.

I developed it using egcc ver 1.02 (I think) from the Debian hamm
	You should have received a user manual and a reference manual
	with MySQL++.  If not, you can read a recent version online:

package with kernel 2.0.33 and a Cryix P150+ cpu.  I am also using
		http://tangentsoft.net/mysql++/doc/

Mysql 3.21.25 that is in the non-free section of the Debian
	Search the MySQL++ mailing list archives if you have more
	questions:

distribution.
		http://lists.mysql.com/plusplus/


Be sure to let me know what you think.  I depend on your feedback.
Building the Library
~~~~~~~~~~~~~~~~~~~~
	As of version 2.1, MySQL++ uses the Bakefile build system. This
	tool creates platform-specific project files and makefiles. We
	currently support these options:

	autoconf:
Thanks,
		For Unixy platforms, including Linux, Mac OS X, and
		Cygwin. See README.unix for details. Supplementary
		details for Cygwin are in README.cygwin.
I can be reached at kevinatk@home.com
--------------------------------------------------------------------
End of original README by Kevin Atkinson

	Visual C++:
		We ship Visual C++ 6 project files, but MySQL++ only

Since October 1999, all maintenance has been transferred to Sinisa
Milivojevic (sinisa@cytanet.com.cy) and Michael Widenius (monty@mysql.com).

		works with Visual C++ 7.1 (a.k.a. Visual Studio 2003)
		or newer. Your version of Visual Studio will upgrade
		these project files for you. See README.vc for details.
Send your feedback to any of these addresses, or even better to the
mailing list mysql-plusplus@lists.mysql.com.

	MinGW:
		We ship Makefiles made for MinGW. These currently only
		work for building static versions of the library,
Since versin 1.1, mysql++ has been prepared to be built with automake and
		which has licensing ramifications. See README.mingw
		for details.
autoconf. 

This will make compilation and  installation much easier. 

Example Programs
~~~~~~~~~~~~~~~~
	You may want to try out the programs in the examples
	subdirectory to ensure that the MySQL++ API and your
You should cd to the root of source directory and run ./configure.
	MySQL database are both working properly.  Also, these
	examples give many examples of the proper use of MySQL++.
	See README.examples for further details.

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.

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.
After configure is run, config.h and Makefiles are generated. 
	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.
If you wish to install mysql++ in a root directory other then /usr/local,
you should run configure with --with-prefix=.....

	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 file first for guidance.  If you follow the advice
	in that file, your patch will be more likely to be accepted.
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++.

If You Want to Hack on MySQL++...
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	If you intend to change the library or example code, please
	read the HACKERS file.

	If you want to change the user manual, read doc/userman/README.
Since version 1.3, mysql++ is fully compliant with latest 2.95.xx series
of compilers.

	If you want to change the reference manual, see the Doxygen
	manual: http://www.stack.nl/~dimitri/doxygen/manual.html

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.
	You do not need to build a Cygwin version of the MySQL server;
	it's still best to use the native Win32 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 most
	other Unix programs.  See README.unix for details.

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 [host] [user] [password] [port]

    On Windows, that would instead be:

        C:\mysql++\> exrun.bat resetdb [host] [user] [pass] [port]

    If you mistakenly run resetdb directly instead of through exrun,
    it will either fail to run because it can't find the MySQL++
    library, or it will find an old version and complain about it.
    None of the other examples are protected against mixed versions
    in this way, but since you have to run resetdb before all the
    other examples, this should pose no problem.

    You can give as few of the parameters as you want, but they must
    be in that order.  That is, if you want to give a user name,
    you must give the host first.  It defaults to localhost with
    your user name, no password, and the default MySQL 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.

        custom1-6: Demonstrates the SSQLS features.  These examples
            are explained in the user manual.

        usequery: Demonstrates Query::use().  Unlike simple3, which
            also showcases this function, this one shows how use
            queries interact with exception handling: when you walk
            past the end of a "use" query set with exceptions enabled,
            MySQL++ throws an exception to indicate end of results,
            which you must catch.

        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.

        tquery: A simple example showing how to use the template query
            facility.

        xaction: Shows how to use the Transaction class to create
            transaction sets which automatically roll back if not
            explicitly committed.

        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 more powerful
            alternative to the SQL WHERE clause.

        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.

        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 the last command
            line argument to be a JPEG file name.  We've included
            examples/logo.jpg as a sample, if you want to use that.

        fieldinf1: 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 the tables in its 'mysql' database.
    
    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.vc 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

MinGW Version
~~~~~~~~~~~~~
	You need a fairly recent version of MinGW for MySQL++ to work.
	As I write this, the current release version includes GCC
	3.4.2, which has known problems.  Unless they've released
	a newer version since I wrote this, you'll probably need to
	install the "candidate" version for best compatibility.


Prerequisite: Create 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
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	Now 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.	This is in order to
	get proper path separator handling.

	If MySQL isn't in C:\Program Files\MySQL\MySQL Server 5.0\ 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 make your changes in mysql++.bkl instead.
		  Then to generate Makefile.mingw from that file,
		  you will need the Win32 port of Bakefile from
		  http://bakefile.sf.net/  The command to do that is:

			  bakefile -f mingw -o Makefile.mingw mysql++.bkl

    Once the library is built and you're satisfied that it's 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++.

Building the Library and Example Programs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	MySQL++ uses the 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 still doesn't work, use --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 threads 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.

Prerequisites
~~~~~~~~~~~~~
    MySQL++ requires Visual Studio 2003 or later.  Earlier versions
    did not support a sufficiently broad subset of Standard C++.

    You also need to have MySQL installed.  The installer may have
    given you the option of whether to install the development files
    or not; if you didn't let it install them, you need to reinstall.


Building the Library and Example Programs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    As of MySQL++ v2.2, there is only one set of project files
    in the top level directory for MySQL++.  We ship VC++6 style
    project files (.dsw and .dsp instead of .sln and .vcproj) due to
    a limitation of the tool we use to generate the project files.
    Just let Visual Studio convert these to the new format.

    If you installed MySQL somewhere other than 
    
        C:\Program Files\MySQL\MySQL Server 5.0\
        
    you need to change the project file settings.  The simplest way
    to do this is to change the link and include file directories in
    the project settings directly.  Although these are technically
    generated files and it's generally bad practice to change generated
    files, if that's all the only change to MySQL++ you need, this
    is harmless.  See below if you want to change the actual source
    files that create the project files.

    Be sure to 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 mysqlpp.dll built
    in Debug mode.  The converse may also be true, but I'm not sure.
    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 version.

    With the library built, run at least the resetdb and simple1
    examples to ensure that the library is working correctly.
    See README.examples for further details.

    Once you're sure the library is working correctly, 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":
          
            libmysql.lib wsock32.lib mysqlpp.lib

    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.dll.


Working With Bakefile
~~~~~~~~~~~~~~~~~~~~~
    MySQL++'s Visual Studio project files aren't maintained directly.
    Instead, they're generated from mysql++.bkl using a tool called
    Bakefile, from http://bakefile.sourceforge.net/  We do it this
    way so we can support multiple platforms and build systems in a
    common way.

    Therefore, if you need to make changes to the project files
    and want to submit those changes back to the MySQL++ project,
    you need to do your changes to mysql++.bkl instead of directly to
    the project files.  There is a native Win32 version of Bakefile up
    on that web site.  Download that and put the directory containing
    bakefile.exe in your Windows PATH.

    The documentation on the Bakefile web site isn't wonderful, but
    is adequate for most things.  If you can't find documentation
    for the feature you need, it's quite likely that Bakefile just
    doesn't support it.  There are things you can do to the project
    settings in Visual Studio that you can't do in Bakefile, since
    it's a cross-platform tool.

    Once you've made your changes, generate the Visual C++ project
    files with this command:

        bakefile -f msvc6prj mysql++.bkl


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++.

Patches for any of these thoughtfully considered!  See the HACKERS file
for instructions on sending patches.

Here's a meta-item that doesn't really fit into any of the categories
below: any time you must hand-roll some SQL code in your program,
consider whether it could be reduced to an API feature that would be
widely useful.  Patches or proposals of this sort are always welcome.


v2.x Features
-------------
    Items in this section may slip to v3.0.  The only thing that
    puts an item in this section instead of the v3.0 one is that
    it can be done without breaking the ABI, which would force
    a feature to v3.0.

    o Add ConnectionPool class, described in this post:

      http://lists.mysql.com/plusplus/6631
    
    o Extend the manipulators to handle nullable versions of
      the types we already support.  Should just be a matter of
      duplicating the existing type-specific manipulator functions,
      and wrapping the types in Null<>.

    o Add a few features to date and time classes:

      - It may be possible to get some nice syntactic sugar,
        such as a way to call SQL functions like NOW() when
        inserting certain Date/Time objects into a Query stream.

      - Arithmetic features?  (See "Practical Algorithms for
        Programmers" by Binstock and Rex.)

    o Add conditional code to the Lockable mechanism to use platform
      mutexes if available, to implement these MySQL C API
      restrictions:

      - Only one query executing at once per connection

      - For "use" queries, Connection (and therefore Query) object must
        remain locked until last row is consumed

      - Safest to have one Connection per thread.  Rules for sharing:
        http://dev.mysql.com/doc/mysql/en/threaded-clients.html

      Need some way to call mysql_thread_init() and
      mysql_thread_end() per thread.  Also, work in some way to
      call mysql_thread_safe() automatically, perhaps the first
      time through the function that calls mysql_thread_init().
      If the C API library reports that it is not thread-safe,
      report this to the caller, perhaps through an exception,
      or simply by refusing to init more than one thread.

    o Build a forward iterator mechanism for ResUse.  Make it
      general enough that you can use it with STL algorithms
      like find_if().  Then make an example to demonstrate this
      augmentation of SELECT.  Also, update usequery example
      to use the iterator.  Tricky bit: how do we make it not
      interfere with subclass Result's random-access iterator?

    o It may be possible to optimize the use of ColData in the return
      from Row::operator[].  Currently, that operator returns a
      temporary ColData object, which contains a copy of the field data
      in its std::string base class instead of a const char* pointer
      to data within the Row object.  If the caller just wants a
      const char*, we can avoid at least one copy here, maybe two. See:

      http://lists.mysql.com/plusplus/4451
      http://lists.mysql.com/plusplus/4460

    o Add Chris Frey's packarray class?


v3.0 Plan
---------

    Version 3.0 is primarily for those changes that will break
    the ABI.  (i.e. removing functions, changing function
    signatures, etc.)  This plan is very tenuous.  Some of this
    could slip to v4.0.

    o Remove all remaining query_reset function parameters, unless
      the function doesn't actually override them.

    o Refactor option mechanism in Connection class into its own
      class.  There are a whole lot of functions, structs and
      enums related to this.

    o Connection::bad_option() should save its built error message
      in an instance variable, and Connection::error() should
      use that when set, so you can get an explanation of option
      setting errors when exceptions are disabled.

    o The Connection::connect() arguments for turning on compression
      and setting the connection timeout should be removed.  These
      can be set directly using Connection::set_option().

    o Add table creation ability to SSQLS.  It has the schema, so...

    o SSQLS should allow table column order to differ from
      structure field order.  Not only will this decouple the
      definitions, it will allow queries for a subset of the fields
      without restricting you to the first N contiguous fields.
      This will require doing a by-name lookup for each field
      when populating it from the MYSQL_ROW object, but if you
      need the highest possible speed, you shouldn't be using
      SSQLS to begin with.

    o Evaluate whether Query's copy ctor should be made private.
      Copying these objects probably never makes sense.

    o Rename Query::success() and Query::success_.  The names imply
      that they only have meaning once a query is tried, but
      that isn't true.  They're an indicator of whether the
      object has had any problems at all, not just problems in
      query execution.

    o Rename Query::def to Query::tquery_defaults.  Makes its
      purpose clearer.  Also, examine all other public data
      members, to see if they have a similar problem.

    o Connection::error() returns const char*, while Query::error()
      returns std::string.  Pick one.

    o Remove MutableColData.  It's only used once in the library,
      within myset.h, and that usage is inefficient to the point
      of wanting replacement anyway.

    o Turn ColData_Tmpl<T> into a concrete class.  Use private
      std::string instance as buffer, and replicate the std::string
      interface publically, delegating to that buffer.
      
    o Use this new class in place of ColData_Tmpl<const_string>, 
      and remove const_string class.

    o More robust fix for the Query stream base class init problem:
      http://www.boost.org/libs/utility/base_from_member.html

      Requires inheritance change, which is why it has to be in v3.

    o Query::str() appends a null byte to the end of the string it
      returns each time it is called.  It is arguable whether it
      should append a null byte at all, since std::string doesn't
      need it.  But even if it does, it at least should recognize
      when the string already has a null, and not keep adding them
      when it is called repeatedly.  See this thread for details:

        http://lists.mysql.com/plusplus/6252

    o Should sql_timestamp typedef not be for DateTime class, not Time
      class?

    o Apply Richard Forrest's iterator patch.

    o The quote manipulator (and presumably the others as well) don't
      work properly with char*.  See this for details:

          http://lists.mysql.com/plusplus/5617

    o Change the unsigned int overloads for operator[] on
      const_subscript_iterator and its subclasses from unsigned
      int to a plain int.  This should fix the ambiguous overload
      problems, such as with row[0].

      See the following threads for reference:
          http://lists.mysql.com/plusplus/4947
          http://lists.mysql.com/plusplus/4952
          http://lists.mysql.com/plusplus/4960
    
    o Several MySQL++ functions wrap the MySQL C API too literally:
      they indicate success by returning 0 instead of true,
      as most other wrapper functions do.

    o Apply Waba's patch allowing Null<T> fields in SSQLSes:
      http://lists.mysql.com/plusplus/5433

    o Deprecate sql_create_basic_*  They have less functionality
      and they're no easier to use than sql_create and friends.

    o Consider whether some of the current boilerplate can be
      made into a base class that all SSQLSes derive from.  Some
      template functions like Query::insert<T> might become regular
      member functions, taking a reference to the SSQLS base class.

    o Abstract all uses of MySQL C API functions into a database
      driver class with a generic interface.  This is a step
      towards database-independence, without the parallel class
      hierarchy required by the MySQL++ 1.7 design.  Also, it
      will make it easier to make class Connection completely
      friend-less.  Right now, the main reason it needs friends
      is because these other classes make C API calls using its
      private MYSQL data member.  The other reasons for it having
      friends aren't nearly as compelling, so it wouldn't be
      hard to justify redesigning Connection to eliminate these
      final reasons.

      While it would be easy to have just one global database
      driver object, it's probably going to be necessary to have
      one per Connection.  Consider what happens when you have one
      program connected to two very different MySQL databases,
      and you indirectly call C API functions that take MYSQL
      parameters.  It's likely that those calls are supposed
      to behave different, depending on the data in that MYSQL
      object; for instance, different character encodings in the
      selected databases.  So, there must somehow be a way to pass
      the database driver's instance pointer down to all objects
      that will need to use the driver.  A side benefit is that
      a single program could talk to multiple different database
      server types.  Imagine a program for importing data from
      PostgreSQL and loading it into a MySQL table, for instance.

    o Query::preview() is just an alias for Query::str().
      Pick one.

    o Remove Query::execute(), store() and use() overloads taking
      a SQLQueryParms object reference.  With the changes in
      v2.2 making the single SQLString overload the end-point
      of the call chain, this just adds one more layer to the
      call chain.  Oh, sure, maybe there is someone out there who
      uses this...but probably not.  Much more likely it's just
      an outdated step that adds nothing to the user experience.

    o The sense of Lockable::lock()'s return value is backwards.
      It should return true if it succeeds in locking the object.

    o Remove simple const char* version of Query::execute(),
      store(), and use()?  SQLString already has a conversion
      ctor taking a const char* string, so there should be no
      need for this explicit overload.



Future Features
---------------

    These changes are not assigned to any particular version.
    They could happen at any time.  If you want one to appear at
    some definite date, get coding and provide a patch!

    o SSQLS v2.  Not sure how it will look yet, but there are ideas
      in play, and patches to study.

    o Figure out some way to name debug DLL and library under VC++
      differently (trailing 'd'?) to prevent some problems due
      to mixing debug and release programs and MySQL++ DLLs.
      This appears to require changes to Bakefile, or some sort of
      post-build hackery.

    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 Row object currently depends on the associated ResUse object
      to stick around through all calls to .at(), because it needs
      the list of field types in the result set to construct
      ColData objects.  This means it's not possible to store
      the result of several queries before accessing the data.
      Currently, this is just a documented limitation, but it
      would be nice if there were a clean way to avoid this.
      Obviously you could just copy the type list when constructing
      the Row object, but that seems pointlessly inefficient.

    o Define operator<< for Fields, Row, ResUse, etc.  In other
      words, there should be a way to get a user-readable version
      of received data without a lot of code.  Perhaps use a CSV
      output format, or a mysql(1) one (ASCII grid).

    o manip.cpp uses mysql_escape_string(), which doesn't take the
      selected database's character set into account.  To do that,
      you must use mysql_real_escape_string(), which differs
      by taking a MYSQL instance as an additional parameter.
      The problem is, Connection owns the relevant MYSQL instance,
      and the manipulator functionality is implemented in global
      functions (operator<<() and such) so they have no direct
      access to the relevant Connection object.

      The key question for all operator<<'s for manipulators
      to ask is, "which Query object am I being inserted into?"
      From there, you can look up the associated Connection object.

      In some cases, this answer to the question is easy, because
      the operator takes an ostream parameter, which can be
      dynamically cast to Query.  From there, it's just a lookup
      table problem.
      
      Other operator<<'s don't take an ostream, but they do take
      a manipulator.  Right now, manipulators are just enum values,
      but they could in fact be classes.  Classes can carry data,
      so there may be a way to "bind" them to the appropriate
      Connection object.  If not, then perhaps some other method
      will pop out of the database driver class idea.  The driver
      object may be able to look up a suitable Connection object
      for the manipulators.

    o MySQL++ handles automatic quoting and escaping differently
      for cout and cerr than for Query streams.  This should
      probably be simplified so that automatic quoting is only
      done for Query streams.  No other stream type should be
      treated specially.

    o Some field_list() functions use the do_nothing manipulator,
      while others use the quote manipulator.  Need to pick one.
      In the vast majority of cases, quoting won't be necessary,
      so make that the default.  But, it should be possible to turn
      it on, if needed.  If all uses of quoting are in template
      code, this can be a #define, allowing different programs
      built on the same system to get different quoting rules.
      Otherwise, it will probably have to be a configure script
      flag, which will "burn" the choice into the built binary.

    o User-settable floating-point comparison precisions?
      Something like this: http://lists.mysql.com/plusplus/3984
      As it currently stands, sql_cmp(double,double) is foolish.
      One shouldn't do exact equality comparison on floating
      point values.

    o Consider using MySQL C API enum constants in
      mysql_type_info::types definition instead of hard-coded
      values.  This could potentially break a lot of
      infrastructure, though, so do it only with care.

    o Support prepared statements.

#!/bin/sh

libtoolize --automake
aclocal 
autoconf
autoheader

for fn in AUTHORS ChangeLog NEWS README
do
  if [ ! -e  "$fn" ]
  then
    touch "$fn"
  fi
done
  
automake -a
./configure $*

#!/bin/sh

ARGS=1
BF_OPTIONS=
while [ $ARGS != 0 ]
do
	case "$1" in
		nodoc)
			BF_OPTIONS="-DBUILDDOCS=no $BF_OPTIONS"
			shift
			;;

		noex)
			BF_OPTIONS="-DBUILDEXAMPLES=no $BF_OPTIONS"
			shift
			;;

		nolib)
			BF_OPTIONS="-DBUILDLIBRARY=no $BF_OPTIONS"
			shift
			;;

		noopt)
			export CXXFLAGS="-g -O0"
			shift
			;;

		pedantic)
			export CXXFLAGS="-g -O2 -ansi -pedantic -Wall -W -Wold-style-cast -Wfloat-equal -Wwrite-strings -Woverloaded-virtual -Wno-long-long"
			shift
			;;

		*)
			ARGS=0
			;;
	esac
done

rm -f config.cache
set -x

./rebake $BF_OPTIONS &&
	bakefile -f gnu -o Makefile.simple -DBUILDLIBRARY=no mysql++.bkl &&
	aclocal -I config -I /usr/local/share/aclocal &&
	autoheader &&
	autoconf &&
	./reconf --enable-maintainer-mode $* &&
	make lib/custom.h lib/querydef.h

#!/bin/sh
rm -f *.{ds?,ncb,sln,suo,vcproj}
rm -f Makefile
rm -f Makefile.{in,mingw,simple}

####### 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

/* config.h.in.  Generated automatically from configure.in by autoheader.  */
/*
** This file has been automatically generated by 'acconfig' from aclocal.m4
** Copyright (C) 1988 Eleftherios Gkioulekas <lf@amath.washington.edu>
**  
** This file is free software; as a special exception the author 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.
*/

/* This is the top section */


/* Define to empty if the keyword does not work.  */
#undef const

/* Define if you have the ANSI C header files.  */
#undef STDC_HEADERS

#undef SQLPLUS_MAJOR_VERSION
#undef SQLPLUS_MINOR_VERSION
#undef SQLPLUS_MICRO_VERSION
#undef SQLPLUS_INTERFACE_AGE
#undef SQLPLUS_BINARY_AGE

/* Define if you have the strtol function.  */
#undef HAVE_STRTOL

/* Define if you have the intl library (-lintl).  */
#undef HAVE_LIBINTL

/* 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

/* This is the bottom section */

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

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)
])

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

#-######################################################################
# mysql++.m4 - Example autoconf macro showing how to find MySQL++
#	library and header files.
#
# Copyright (c) 2004-2005 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.0, 2005/07/13
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>],
		[std::string s; mysqlpp::escape_string(s)])],
		ac_cv_mysqlpp_devel=yes,
		AC_MSG_ERROR(no))
])]) dnl End MYSQLPP_DEVEL

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/x86_64-linux-gnu /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/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

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