Several classes changed names in this release:

When first building existing code against this version, you may find it helpful to define the macro MYSQLPP_OLD_CLASS_NAMES in your program’s build options. This will turn on some macros that set up aliases for the new class names matching their corresponding old names. Then, when you’ve fixed up any other issues that may prevent your program from building with the new MySQL++, you can turn it back off and fix up any class name differences.

If you were only using ColData in a BLOB context, you should use sql_blob or one of the related typedefs defined in lib/sql_types.h instead, to insulate your code from changes like these.

The SQLString change shouldn’t affect you, as this class was not designed to be used by end user code. But, due to the old name and the fact that it used to derive from std::string, some might have been tempted to use it as an enhanced std::string. Such code will undoubtedly break, but can probably be fixed by just changing it to use std::string instead.

The option setting mechanism has been redesigned. (Yes, again.) There used to be an enum in Connection with a value for each option we understood, and an overload of Connection::set_option() for each argument type we understood. It was possible to pass any option value to any set_option() overload, and the problem would only be detected at run time. Now each option is represented by a class derived from the new Option abstract base class, and set_option() simply takes a pointer to one of these objects. See examples/multiquery.cpp for the syntax. Since each Option subclass takes only the parameter types it actually understands, it’s now completely type-safe at compile time.

The new option setting mechanism also has the virtue of being more powerful so it let us replace several existing things within Connection with new options:

Collapsed Connection’s host, port, and socket_name parameters down into a new combined server parameter which is parsed to determine what kind of connection you mean. These interfaces are still compatible with v2.3 and earlier up through the port parameter.

Moved Connection::affected_rows(), info() and insert_id() methods to class Query, as they relate to the most recently-executed query.

Changed the return type of Connection::ping() from int to bool. If you were calling ping() in bool context or using its return value in bool context, you will need to reverse the sense of the test because the previous return code used zero to mean success. Now it returns true to indicate success.

Renamed several methods:

Also, removed close() in favor of disconnect(), which has always done the same thing.

The sql_timestamp typedef is now an alias for DateTime, not Time.

There used to be implicit conversion constructors from ColData (now String), std::string and const char* for the Date, DateTime, and Time classes. It’s still possible to do these conversions, but only explicitly. (This had to be done to make Null<T> work in SSQLSes.)

The most likely place to run into problems as a result of this change is in code like this:

void some_function(const mysqlpp::DateTime& dt);

some_function("2007-12-22");

The function call needs to be changed to:

some_function(mysqlpp::DateTime("2007-12-22"));

If an error occurs during the processing of a “use” query (as opposed to the initial execution) we throw the new UseQueryError exception instead of BadQuery.

If you pass bad values to the Row ctor so that it can’t initialize itself properly, it throws the ObjectNotInitialized exception instead of BadQuery.

Together, these two changes mean that BadQuery is now used solely to indicate a problem executing the actual SQL query statement.

Field is now a real C++ class, not just a typedef for the corresponding C API class. Major portability impacts are:

Fields used to be a std::vector work-alike which worked with the C API to access fields and return them as though they were simply contained directly within the Fields object. Now that we have a real MySQL++ class to hold information about each field without reference to the C API, we were able to replace the Fields class with:

typedef std::vector<Field> Fields;

If anything, this should give a pure superset of the old functionality, but it’s possible it could break end user code.

If you were using char as an 8-bit integer in query building, there are several places in MySQL++ v3 where it will now be treated as a single-character string. MySQL++ has had the tiny_int class for many years now specifically to provide a true 8-bit integer without the semantic confusion surrounding the old C char type. Either use tiny_int, or use the SQL type aliases sql_tinyint and sql_tinyint_unsigned instead.

The ‘r’ and ‘R’ template query parameter modifiers were removed. They made the library do quoting and both quoting and escaping (respectively) regardless of the data type of the parameter. There are no corresponding Query stream manipulators, so for symmetery we had to decide whether to add such manipulators or remove the tquery modifiers. There should never be a reason to force quoting or escaping other than to work around a MySQL++ bug, and it’s better to just fix the bug than work around it, so removed the tquery modifiers.

Query::store_next() and Result::fetch_row() no longer throw the EndOfResults and EndOfResultSets exceptions; these are not exceptional conditions! These methods simply return false when you hit the end of the result set now.

Renamed Query::def to Query::template_defaults to make its purpose clearer.

Removed Query::preview(). The most direct replacement for this set of overloaded methods is the parallel set of str() methods, which were just aliases before. (Chose str() over preview() because it’s standard C++ nomenclature.) But if you’re just looking to get a copy of a built query string and you aren’t using template queries, you can now insert the Query into a stream and get the same result.

For example, a lot of code in the examples that used to say things like:

cout << query.preview() << endl;

now looks like this:

cout << query << endl;

In addition to the class name changes described above, UseQueryResult is no longer StoreQueryResult’s base class. There is a new abstract class called ResultBase containing much of what used to be in ResUse, and it is the base of both of these concrete result set types. This should only affect your code if you were using ResUse references to refer to Result objects.

Removed a bunch of duplicate methods:

Renamed several methods for “grammar” reasons. For example, some methods returned a single object but had a “plural” name, implying that it returned a container of objects. In cases like this, we changed the name to agree with the return value. Some of these also fall into the duplicate method category above:

Removed several “smelly” methods:

ResUse::field_num() would unconditionally throw a BadFieldName exception when you asked for a field that doesn’t exist. Now, if exceptions are disabled on the object, it just returns -1.

SimpleResult’s member variables are all now private, and have read-only accessor functions of the same name.

Code like this used to work:

mysqlpp::Row row;
mysqlpp::Result::size_type i;
for (i = 0; row = res[i]; ++i) {
  // Do something with row here
}

That is, indexing past the end of a “store” result set would just return an empty row object, which tests as false in bool context, so it ends the loop. Now that StoreQueryResult is a std::vector derivative, this either crashes your program or causes the standard library to throw an exception, depending on what debugging features your version of STL has. The proper technique is:

mysqlpp::Row row;
mysqlpp::StoreQueryResult::size_type i;
for (i = 0; i < res.num_rows(); ++i) {
  row = res[i];
  // Do something with row here
}

...or, in a more C++ish idiom:

mysqlpp::Row row;
mysqlpp::StoreQueryResult::const_iterator it;
for (it = res.begin(); it != res.end(); ++it) {
  row = *it;
  // Do something with row here
}

Removed Row::raw_data(), raw_size() and raw_string(). These were useful with BLOB data back when MySQL++ didn’t handle embedded null characters very well, and when copies of ColData objects were expensive. Neither is true now, so they have no value any more. Equivalent calls are:

mysqlpp::String s = row[0];
s.data();                          // raw_data() equivalent
s.length();                        // raw_size() equivalent
std::string(s.data(), s.length()); // raw_string() equivalent

Row::operator[](const char*) would unconditionally throw a BadFieldName exception when you asked for a field that doesn’t exist. Now, if exceptions are disabled on the Row object, it just returns a reference to an empty String object. You can tell when this happens because such an object tests as false in bool context.

Renamed custom* to ssqls*. There is a backwards-compatibility header custom.h which includes ssqls.h for you, but it will go away in a future version of MySQL++.

SSQLSes get populated by field name now, not by field order. In v2, it was absolutely required that your SSQLS had its fields declared in exactly the same order as the fields in the database server, and there could be no gaps. An ALTER TABLE command would almost always necessitate redefining the corresponding SSQLS and rebuilding your program. Some alterations actually made using SSQLS impossible. For the most part, this change just gives your program additional flexibility in the face of future changes. However, code that was taking advantage of this low-level fact will break when moving to v3. Before I explain how, let’s go over the high-level functional changes you’ll find in v3’s SSQLS mechanism.

Because MySQL++ no longer needs the SSQLS field order to match the SQL field order, the sql_create_c_order_* SSQLS creation macro was dropped in v3. We were also able to drop the ordering parameters from sql_create_complete_*. That in turn means there is no longer a difference between the way it and sql_create_c_names_* work, so the latter was also dropped. Thus, there are now only two groups of SSQLS creation macros left: sql_create_*, which works pretty much as it always has, and sql_create_complete_*, which is the same except for the lack of ordering parameters.

In general, you should be using sql_create_* for all SSQLSes unless you need to use different names for data members in C++ than you use for the corresponding columns in SQL. In that case, use sql_create_complete_* instead.

In v2, it was possible to have different SQL column names than SSQLS data member names while still using sql_create_* if you only used SSQLS for data retrieval.^[25] In v3, you must use sql_create_complete_* for absolutely all uses of SSQLS when you want the C++ field names to differ from the SQL column names.

The new Null<T> support in SSQLSes causes an internal compiler error in Visual C++ 2003. (VC++ 2005 and newer have no trobule with it.) A poll on the mailing list says there aren’t many people still stuck on this version, so we just ifdef’d out the SSQLS mechanism and all the examples that use it when built with VC++ 2003. If this affects you, see Section 5.15, “SSQLS and Visual C++ 2003” for suggestions on ways to cope.

If you are using types other than MySQL++’s sql_* ones ^[26] in your SSQLSes, code that previously worked may now see TypeLookupFailed exceptions. (This can be thrown even if exceptions are otherwise disabled in MySQL++.) This version of MySQL++ is stricter about mapping SQL to C++ type information, and vice versa. If the library can’t find a suitable mapping from one type system to the other, it throws this exception, because its only other option would be to crash or raise an assertion. This typically happens when building SQL queries, so you can probably handle it the same way as if the subsequent query excecution failed. If you’re catching the generic mysqlpp::Exception, your error handling code might not need to change. If you see this exception, it does mean you need to look into your use of data types, though. The table that controls this is mysql_type_info::types, defined at the top of lib/type_info.cpp. Every data type in lib/sql_types.h has a corresponding record in this table, so if you stick to those types, you’ll be fine. It’s also okay to use types your C++ compiler can convert directly to these predefined types.

The _table static member variable for each SSQLS is now private. The recommended way to access this remains unchanged: the table() static member function.

table() used to return a modifiable reference to the table name. Now there are two overloads, one which returns an unmodifiable pointer to the table name, and the other which takes const char* so you can override the default table name. So, the code we used to recommend for changing the SSQLS’s table name:

my_ssqls_type::table() = "MyTableName";

now needs to be:

my_ssqls_type::table("MyTableName");

MySQL++ does quoting and escaping much more selectively now. Basically, if the library can tell you’re not building a SQL query using one of the standard methods, it assumes you’re outputting values for human consumption, so it disables quoting and SQL escaping. If you need to build your own mechanism to replace this, quoting is easy to do, and Query::escape_string() can do SQL escaping for you.

Removed success() in Connection, Query and SimpleResult (neé ResNSel) and simply made these classes testable in bool context to get the same information. An additional change in Connection is that it used to be considered “unsuccessful” when the connection was down. Since the sense of this test is now whether the object is in a good state, it only returns false when the connection attempt fails. Call Connection::is_connected() if you just want to test whether the connection is up.

The debug mode build of the library now has a "_d" suffix for Visual C++, and Xcode. This lets you have both versions installed without conflict. The release build uses the current naming scheme. If you have an existing program building against MySQL++ on these platforms, you’ll need to change your build options to use the new name in debug mode.

Renamed NO_LONG_LONGS to MYSQLPP_NO_LONG_LONGS to avoid a risk of collision in the global macro namespace.