mysql-connector-c++: headers diff between 1.1.2 and 1.1.6 versions

	config.h	config.h
	/*	/*

	Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reser ved.	Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reser ved.

	The MySQL Connector/C++ is licensed under the terms of the GPLv2	The MySQL Connector/C++ is licensed under the terms of the GPLv2
	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
	MySQL Connectors. There are special exceptions to the terms and	MySQL Connectors. There are special exceptions to the terms and
	conditions of the GPL as it is applied to this software, see the	conditions of the GPL as it is applied to this software, see the
	FLOSS License Exception	FLOSS License Exception
	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.

	This program is free software; you can redistribute it and/or modify	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published	it under the terms of the GNU General Public License as published

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	connection.h	connection.h
	/*	/*

	Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved .	Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved .

	The MySQL Connector/C++ is licensed under the terms of the GPLv2	The MySQL Connector/C++ is licensed under the terms of the GPLv2
	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
	MySQL Connectors. There are special exceptions to the terms and	MySQL Connectors. There are special exceptions to the terms and
	conditions of the GPLv2 as it is applied to this software, see the	conditions of the GPLv2 as it is applied to this software, see the
	FLOSS License Exception	FLOSS License Exception
	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.

	This program is free software; you can redistribute it and/or modify	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published	it under the terms of the GNU General Public License as published

	skipping to change at line 29	skipping to change at line 29

	You should have received a copy of the GNU General Public License along	You should have received a copy of the GNU General Public License along
	with this program; if not, write to the Free Software Foundation, Inc.,	with this program; if not, write to the Free Software Foundation, Inc.,
	51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA	51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/	*/

	#ifndef _SQL_CONNECTION_H_	#ifndef _SQL_CONNECTION_H_
	#define _SQL_CONNECTION_H_	#define _SQL_CONNECTION_H_

	#include <map>	#include <map>

	#include <boost/variant.hpp>

	#include "build_config.h"	#include "build_config.h"
	#include "warning.h"	#include "warning.h"
	#include "sqlstring.h"	#include "sqlstring.h"

		#include "variant.h"

	namespace sql	namespace sql
	{	{


	typedef boost::variant<int, double, bool, sql::SQLString > ConnectPropertyV al;	typedef sql::Variant ConnectPropertyVal;

	typedef std::map< sql::SQLString, ConnectPropertyVal > ConnectOptionsMap;	typedef std::map< sql::SQLString, ConnectPropertyVal > ConnectOptionsMap;

	class DatabaseMetaData;	class DatabaseMetaData;
	class PreparedStatement;	class PreparedStatement;
	class Statement;	class Statement;
	class Driver;	class Driver;

	typedef enum transaction_isolation	typedef enum transaction_isolation
	{	{

	skipping to change at line 100	skipping to change at line 100
	virtual sql::SQLString getCatalog() = 0;	virtual sql::SQLString getCatalog() = 0;

	virtual Driver *getDriver() = 0;	virtual Driver *getDriver() = 0;

	virtual sql::SQLString getSchema() = 0;	virtual sql::SQLString getSchema() = 0;

	virtual sql::SQLString getClientInfo() = 0;	virtual sql::SQLString getClientInfo() = 0;

	virtual void getClientOption(const sql::SQLString & optionName, void * optionValue) = 0;	virtual void getClientOption(const sql::SQLString & optionName, void * optionValue) = 0;


		virtual sql::SQLString getClientOption(const sql::SQLString & option
		Name) = 0;

	virtual DatabaseMetaData * getMetaData() = 0;	virtual DatabaseMetaData * getMetaData() = 0;

	virtual enum_transaction_isolation getTransactionIsolation() = 0;	virtual enum_transaction_isolation getTransactionIsolation() = 0;

	virtual const SQLWarning * getWarnings() = 0;	virtual const SQLWarning * getWarnings() = 0;

	virtual bool isClosed() = 0;	virtual bool isClosed() = 0;

	virtual bool isReadOnly() = 0;	virtual bool isReadOnly() = 0;


		virtual bool isValid() = 0;

		virtual bool reconnect() = 0;

	virtual sql::SQLString nativeSQL(const sql::SQLString& sql) = 0;	virtual sql::SQLString nativeSQL(const sql::SQLString& sql) = 0;

	virtual PreparedStatement * prepareStatement(const sql::SQLString& s ql) = 0;	virtual PreparedStatement * prepareStatement(const sql::SQLString& s ql) = 0;

	virtual PreparedStatement * prepareStatement(const sql::SQLString& s ql, int autoGeneratedKeys) = 0;	virtual PreparedStatement * prepareStatement(const sql::SQLString& s ql, int autoGeneratedKeys) = 0;

	virtual PreparedStatement * prepareStatement(const sql::SQLString& s ql, int* columnIndexes) = 0;	virtual PreparedStatement * prepareStatement(const sql::SQLString& s ql, int* columnIndexes) = 0;

	virtual PreparedStatement * prepareStatement(const sql::SQLString& s ql, int resultSetType, int resultSetConcurrency) = 0;	virtual PreparedStatement * prepareStatement(const sql::SQLString& s ql, int resultSetType, int resultSetConcurrency) = 0;


	skipping to change at line 138	skipping to change at line 144
	virtual void rollback(Savepoint * savepoint) = 0;	virtual void rollback(Savepoint * savepoint) = 0;

	virtual void setAutoCommit(bool autoCommit) = 0;	virtual void setAutoCommit(bool autoCommit) = 0;

	virtual void setCatalog(const sql::SQLString& catalog) = 0;	virtual void setCatalog(const sql::SQLString& catalog) = 0;

	virtual void setSchema(const sql::SQLString& catalog) = 0;	virtual void setSchema(const sql::SQLString& catalog) = 0;

	virtual sql::Connection * setClientOption(const sql::SQLString & opt ionName, const void * optionValue) = 0;	virtual sql::Connection * setClientOption(const sql::SQLString & opt ionName, const void * optionValue) = 0;


		virtual sql::Connection * setClientOption(const sql::SQLString & opt
		ionName, const sql::SQLString & optionValue) = 0;

	virtual void setHoldability(int holdability) = 0;	virtual void setHoldability(int holdability) = 0;

	virtual void setReadOnly(bool readOnly) = 0;	virtual void setReadOnly(bool readOnly) = 0;

	virtual Savepoint * setSavepoint() = 0;	virtual Savepoint * setSavepoint() = 0;

	virtual Savepoint * setSavepoint(const sql::SQLString& name) = 0;	virtual Savepoint * setSavepoint(const sql::SQLString& name) = 0;

	virtual void setTransactionIsolation(enum_transaction_isolation leve l) = 0;	virtual void setTransactionIsolation(enum_transaction_isolation leve l) = 0;


End of changes. 7 change blocks.
	3 lines changed or deleted	13 lines changed or added

	exception.h	exception.h
	/*	/*

	Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved .	Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved .

	The MySQL Connector/C++ is licensed under the terms of the GPLv2	The MySQL Connector/C++ is licensed under the terms of the GPLv2
	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
	MySQL Connectors. There are special exceptions to the terms and	MySQL Connectors. There are special exceptions to the terms and
	conditions of the GPLv2 as it is applied to this software, see the	conditions of the GPLv2 as it is applied to this software, see the
	FLOSS License Exception	FLOSS License Exception
	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.

	This program is free software; you can redistribute it and/or modify	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published	it under the terms of the GNU General Public License as published

	skipping to change at line 121	skipping to change at line 121
	InvalidInstanceException(const InvalidInstanceException& e) : SQLExc eption(e.what(), e.sql_state, e.errNo) { }	InvalidInstanceException(const InvalidInstanceException& e) : SQLExc eption(e.what(), e.sql_state, e.errNo) { }
	InvalidInstanceException(const std::string& reason) : SQLException(r eason, "", 0) {}	InvalidInstanceException(const std::string& reason) : SQLException(r eason, "", 0) {}
	};	};

	struct CPPCONN_PUBLIC_FUNC NonScrollableException : public SQLException	struct CPPCONN_PUBLIC_FUNC NonScrollableException : public SQLException
	{	{
	NonScrollableException(const NonScrollableException& e) : SQLExcepti on(e.what(), e.sql_state, e.errNo) { }	NonScrollableException(const NonScrollableException& e) : SQLExcepti on(e.what(), e.sql_state, e.errNo) { }
	NonScrollableException(const std::string& reason) : SQLException(rea son, "", 0) {}	NonScrollableException(const std::string& reason) : SQLException(rea son, "", 0) {}
	};	};


		struct CPPCONN_PUBLIC_FUNC SQLUnsupportedOptionException : public SQLExcept
		ion
		{
		SQLUnsupportedOptionException(const SQLUnsupportedOptionException& e
		, const std::string conn_option) :
		SQLException(e.what(), e.sql_state, e.errNo),
		option(conn_option )
		{}

		SQLUnsupportedOptionException(const std::string& reason, const std::
		string conn_option) :
		SQLException(reason, "", 0),
		option(conn_option )
		{}

		const char *getConnectionOption() const
		{
		return option.c_str();
		}

		~SQLUnsupportedOptionException() throw () {};
		protected:
		const std::string option;
		};

	} /* namespace sql */	} /* namespace sql */

	#endif /* _SQL_EXCEPTION_H_ */	#endif /* _SQL_EXCEPTION_H_ */

End of changes. 2 change blocks.
	1 lines changed or deleted	26 lines changed or added

	sqlstring.h	sqlstring.h
	/*	/*

	Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved .	Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved .

	The MySQL Connector/C++ is licensed under the terms of the GPLv2	The MySQL Connector/C++ is licensed under the terms of the GPLv2
	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
	MySQL Connectors. There are special exceptions to the terms and	MySQL Connectors. There are special exceptions to the terms and
	conditions of the GPLv2 as it is applied to this software, see the	conditions of the GPLv2 as it is applied to this software, see the
	FLOSS License Exception	FLOSS License Exception
	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.

	This program is free software; you can redistribute it and/or modify	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published	it under the terms of the GNU General Public License as published

	skipping to change at line 29	skipping to change at line 29

	You should have received a copy of the GNU General Public License along	You should have received a copy of the GNU General Public License along
	with this program; if not, write to the Free Software Foundation, Inc.,	with this program; if not, write to the Free Software Foundation, Inc.,
	51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA	51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/	*/

	#ifndef _SQL_STRING_H_	#ifndef _SQL_STRING_H_
	#define _SQL_STRING_H_	#define _SQL_STRING_H_

	#include <string>	#include <string>

		#include <algorithm>
	#include "build_config.h"	#include "build_config.h"
	#include <iostream>	#include <iostream>

	namespace sql	namespace sql
	{	{
	class CPPCONN_PUBLIC_FUNC SQLString	class CPPCONN_PUBLIC_FUNC SQLString
	{	{
	std::string realStr;	std::string realStr;

	public:	public:

	skipping to change at line 105	skipping to change at line 106
	int compare(const char * s) const	int compare(const char * s) const
	{	{
	return realStr.compare(s);	return realStr.compare(s);
	}	}

	int compare(size_t pos1, size_t n1, const char * s) const	int compare(size_t pos1, size_t n1, const char * s) const
	{	{
	return realStr.compare(pos1, n1, s);	return realStr.compare(pos1, n1, s);
	}	}


		int caseCompare(const SQLString &s) const
		{
		std::string tmp(realStr), str(s);
		std::transform(tmp.begin(), tmp.end(), tmp.begin(),
		::tolower);
		std::transform(str.begin(), str.end(), str.begin(),
		::tolower);
		return tmp.compare(str);
		}

		int caseCompare(const char * s) const
		{
		std::string tmp(realStr), str(s);
		std::transform(str.begin(), str.end(), str.begin(),
		::tolower);
		std::transform(tmp.begin(), tmp.end(), tmp.begin(),
		::tolower);
		return tmp.compare(str);
		}

		int caseCompare(size_t pos1, size_t n1, const char * s) cons
		t
		{
		std::string tmp(realStr.c_str() + pos1, n1), str(s);
		std::transform(str.begin(), str.end(), str.begin(),
		::tolower);
		std::transform(tmp.begin(), tmp.end(), tmp.begin(),
		::tolower);
		return tmp.compare(str);
		}

	const std::string & asStdString() const	const std::string & asStdString() const
	{	{
	return realStr;	return realStr;
	}	}

	const char * c_str() const	const char * c_str() const
	{	{
	return realStr.c_str();	return realStr.c_str();
	}	}


End of changes. 3 change blocks.
	1 lines changed or deleted	33 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	mysql_connection.h	mysql_connection.h
	/*	/*

	Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved .	Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved .

	The MySQL Connector/C++ is licensed under the terms of the GPLv2	The MySQL Connector/C++ is licensed under the terms of the GPLv2
	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most	<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
	MySQL Connectors. There are special exceptions to the terms and	MySQL Connectors. There are special exceptions to the terms and
	conditions of the GPLv2 as it is applied to this software, see the	conditions of the GPLv2 as it is applied to this software, see the
	FLOSS License Exception	FLOSS License Exception
	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.	<http://www.mysql.com/about/legal/licensing/foss-exception.html>.

	This program is free software; you can redistribute it and/or modify	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published	it under the terms of the GNU General Public License as published

	skipping to change at line 102	skipping to change at line 102
	sql::SQLString getCatalog();	sql::SQLString getCatalog();

	Driver *getDriver();	Driver *getDriver();

	sql::SQLString getSchema();	sql::SQLString getSchema();

	sql::SQLString getClientInfo();	sql::SQLString getClientInfo();

	void getClientOption(const sql::SQLString & optionName, void * optio nValue);	void getClientOption(const sql::SQLString & optionName, void * optio nValue);


		sql::SQLString getClientOption(const sql::SQLString & optionName);

	sql::DatabaseMetaData * getMetaData();	sql::DatabaseMetaData * getMetaData();

	enum_transaction_isolation getTransactionIsolation();	enum_transaction_isolation getTransactionIsolation();

	const SQLWarning * getWarnings();	const SQLWarning * getWarnings();

	bool isClosed();	bool isClosed();

	bool isReadOnly();	bool isReadOnly();


		bool isValid();

		bool reconnect();

	sql::SQLString nativeSQL(const sql::SQLString& sql);	sql::SQLString nativeSQL(const sql::SQLString& sql);

	sql::PreparedStatement * prepareStatement(const sql::SQLString& sql) ;	sql::PreparedStatement * prepareStatement(const sql::SQLString& sql) ;

	sql::PreparedStatement * prepareStatement(const sql::SQLString& sql, int autoGeneratedKeys);	sql::PreparedStatement * prepareStatement(const sql::SQLString& sql, int autoGeneratedKeys);

	sql::PreparedStatement * prepareStatement(const sql::SQLString& sql, int columnIndexes[]);	sql::PreparedStatement * prepareStatement(const sql::SQLString& sql, int columnIndexes[]);

	sql::PreparedStatement * prepareStatement(const sql::SQLString& sql, int resultSetType, int resultSetConcurrency);	sql::PreparedStatement * prepareStatement(const sql::SQLString& sql, int resultSetType, int resultSetConcurrency);


	skipping to change at line 140	skipping to change at line 146
	void rollback(Savepoint * savepoint);	void rollback(Savepoint * savepoint);

	void setAutoCommit(bool autoCommit);	void setAutoCommit(bool autoCommit);

	void setCatalog(const sql::SQLString& catalog);	void setCatalog(const sql::SQLString& catalog);

	void setSchema(const sql::SQLString& catalog);	void setSchema(const sql::SQLString& catalog);

	sql::Connection * setClientOption(const sql::SQLString & optionName, const void * optionValue);	sql::Connection * setClientOption(const sql::SQLString & optionName, const void * optionValue);


		sql::Connection * setClientOption(const sql::SQLString & optionName,
		const sql::SQLString & optionValue);

	void setHoldability(int holdability);	void setHoldability(int holdability);

	void setReadOnly(bool readOnly);	void setReadOnly(bool readOnly);

	sql::Savepoint * setSavepoint();	sql::Savepoint * setSavepoint();

	sql::Savepoint * setSavepoint(const sql::SQLString& name);	sql::Savepoint * setSavepoint(const sql::SQLString& name);

	void setTransactionIsolation(enum_transaction_isolation level);	void setTransactionIsolation(enum_transaction_isolation level);

	virtual sql::SQLString getSessionVariable(const sql::SQLString & var name);	virtual sql::SQLString getSessionVariable(const sql::SQLString & var name);

	virtual void setSessionVariable(const sql::SQLString & varname, cons t sql::SQLString & value);	virtual void setSessionVariable(const sql::SQLString & varname, cons t sql::SQLString & value);


		virtual void setSessionVariable(const sql::SQLString & varname, unsi
		gned int value);

	virtual sql::SQLString getLastStatementInfo();	virtual sql::SQLString getLastStatementInfo();

	private:	private:
	/* We do not really think this class has to be subclassed*/	/* We do not really think this class has to be subclassed*/
	void checkClosed();	void checkClosed();
	void init(std::map< sql::SQLString, sql::ConnectPropertyVal > & prop erties);	void init(std::map< sql::SQLString, sql::ConnectPropertyVal > & prop erties);

	Driver * driver;	Driver * driver;
	boost::shared_ptr< NativeAPI::NativeConnectionWrapper > proxy;	boost::shared_ptr< NativeAPI::NativeConnectionWrapper > proxy;

	/* statement handle to execute queries initiated by driver. Perhaps it is	/* statement handle to execute queries initiated by driver. Perhaps it is
	a good idea to move it to a separate helper class */	a good idea to move it to a separate helper class */
	boost::scoped_ptr< ::sql::mysql::MySQL_Statement > service;	boost::scoped_ptr< ::sql::mysql::MySQL_Statement > service;


	MySQL_ConnectionData * intern; /* pimpl */	boost::scoped_ptr< ::sql::mysql::MySQL_ConnectionData > intern; /* p impl */

	/* Prevent use of these */	/* Prevent use of these */
	MySQL_Connection(const MySQL_Connection &);	MySQL_Connection(const MySQL_Connection &);
	void operator=(MySQL_Connection &);	void operator=(MySQL_Connection &);
	};	};

	} /* namespace mysql */	} /* namespace mysql */
	} /* namespace sql */	} /* namespace sql */

	#endif // _MYSQL_CONNECTION_H_	#endif // _MYSQL_CONNECTION_H_

End of changes. 6 change blocks.
	2 lines changed or deleted	14 lines changed or added