Major plugin refactor and cleanup.

Switched to POCO library for unified platform/library interface.
Deprecated the external module API. It was creating more problems than solving.
Removed most built-in libraries in favor of system libraries for easier maintenance.
Cleaned and secured code with help from static analyzers.

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/Binder.h

@@ -0,0 +1,253 @@
+//
+// Binder.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  Binder
+//
+// Definition of the Binder class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_Binder_INCLUDED
+#define Data_MySQL_Binder_INCLUDED
+
+
+#include "Poco/Data/MySQL/MySQL.h"
+#include "Poco/Data/AbstractBinder.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Data/MySQL/MySQLException.h"
+#include <mysql.h>
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+class MySQL_API Binder: public Poco::Data::AbstractBinder
+	/// Binds placeholders in the sql query to the provided values. Performs data types mapping.
+{
+public:
+	typedef SharedPtr<Binder> Ptr;
+
+	Binder();
+		/// Creates the Binder.
+
+	virtual ~Binder();
+		/// Destroys the Binder.
+
+	virtual void bind(std::size_t pos, const Poco::Int8& val, Direction dir);
+		/// Binds an Int8.
+
+	virtual void bind(std::size_t pos, const Poco::UInt8& val, Direction dir);
+		/// Binds an UInt8.
+
+	virtual void bind(std::size_t pos, const Poco::Int16& val, Direction dir);
+		/// Binds an Int16.
+
+	virtual void bind(std::size_t pos, const Poco::UInt16& val, Direction dir);
+		/// Binds an UInt16.
+
+	virtual void bind(std::size_t pos, const Poco::Int32& val, Direction dir);
+		/// Binds an Int32.
+
+	virtual void bind(std::size_t pos, const Poco::UInt32& val, Direction dir);
+		/// Binds an UInt32.
+
+	virtual void bind(std::size_t pos, const Poco::Int64& val, Direction dir);
+		/// Binds an Int64.
+
+	virtual void bind(std::size_t pos, const Poco::UInt64& val, Direction dir);
+		/// Binds an UInt64.
+
+#ifndef POCO_INT64_IS_LONG
+	virtual void bind(std::size_t pos, const long& val, Direction dir = PD_IN);
+		/// Binds a long.
+
+	virtual void bind(std::size_t pos, const unsigned long& val, Direction dir = PD_IN);
+		/// Binds an unsigned long.
+#endif 
+
+	virtual void bind(std::size_t pos, const bool& val, Direction dir);
+		/// Binds a boolean.
+
+	virtual void bind(std::size_t pos, const float& val, Direction dir);
+		/// Binds a float.
+
+	virtual void bind(std::size_t pos, const double& val, Direction dir);
+		/// Binds a double.
+
+	virtual void bind(std::size_t pos, const char& val, Direction dir);
+		/// Binds a single character.
+
+	virtual void bind(std::size_t pos, const std::string& val, Direction dir);
+		/// Binds a string.
+
+	virtual void bind(std::size_t pos, const Poco::Data::BLOB& val, Direction dir);
+		/// Binds a BLOB.
+
+	virtual void bind(std::size_t pos, const Poco::Data::CLOB& val, Direction dir);
+		/// Binds a CLOB.
+
+	virtual void bind(std::size_t pos, const DateTime& val, Direction dir);
+		/// Binds a DateTime.
+
+	virtual void bind(std::size_t pos, const Date& val, Direction dir);
+		/// Binds a Date.
+
+	virtual void bind(std::size_t pos, const Time& val, Direction dir);
+		/// Binds a Time.
+
+	virtual void bind(std::size_t pos, const NullData& val, Direction dir);
+		/// Binds a null.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int8>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int8>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt8>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt8>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int16>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int16>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt16>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt16>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int32>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int32>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt32>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt32>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int64>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int64>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt64>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt64>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<bool>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<bool>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<bool>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<float>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<float>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<float>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<double>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<double>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<double>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<char>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<char>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<char>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<BLOB>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<BLOB>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<CLOB>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<CLOB>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<CLOB>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<DateTime>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<DateTime>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Date>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Date>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Date>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<Time>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<Time>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<Time>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<NullData>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<NullData>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<NullData>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::vector<std::string>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::deque<std::string>& val, Direction dir = PD_IN);
+
+	virtual void bind(std::size_t pos, const std::list<std::string>& val, Direction dir = PD_IN);
+
+	std::size_t size() const;
+		/// Return count of binded parameters
+
+	MYSQL_BIND* getBindArray() const;
+		/// Return array
+
+private:
+	Binder(const Binder&);
+		/// Don't copy the binder
+
+	virtual void bind(std::size_t, const char* const&, Direction)
+		/// Binds a const char ptr.
+		/// This is a private no-op in this implementation
+		/// due to security risk.
+	{
+	}
+
+	void realBind(std::size_t pos, enum_field_types type, const void* buffer, int length, bool isUnsigned = false);
+		/// Common bind implementation
+
+private:
+	std::vector<MYSQL_BIND> _bindArray;
+	std::vector<MYSQL_TIME*> _dates;
+};
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif // Data_MySQL_Binder_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/Connector.h

@@ -0,0 +1,60 @@
+//
+// Connector.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  Connector
+//
+// Definition of the Connector class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_Connector_INCLUDED
+#define Data_MySQL_Connector_INCLUDED
+
+
+#include "Poco/Data/MySQL/MySQL.h"
+#include "Poco/Data/Connector.h"
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+class MySQL_API Connector: public Poco::Data::Connector
+	/// Connector instantiates MySQL SessionImpl objects.
+{
+public:
+	static std::string KEY;
+
+	Connector();
+		/// Creates the Connector.
+	
+	virtual ~Connector();
+		/// Destroys the Connector.
+
+	virtual const std::string& name() const;
+		/// Returns the name associated with this connector.
+
+	virtual Poco::AutoPtr<Poco::Data::SessionImpl> createSession(const std::string& connectionString,
+		std::size_t timeout = Poco::Data::SessionImpl::LOGIN_TIMEOUT_DEFAULT);
+		/// Creates a MySQL SessionImpl object and initializes it with the given connectionString.
+
+	static void registerConnector();
+		/// Registers the Connector under the Keyword Connector::KEY at the Poco::Data::SessionFactory
+
+	static void unregisterConnector();
+		/// Unregisters the Connector under the Keyword Connector::KEY at the Poco::Data::SessionFactory
+};
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif // Data_MySQL_Connector_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/Extractor.h

@@ -0,0 +1,335 @@
+//
+// Extractor.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  Extractor
+//
+// Definition of the Extractor class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_Extractor_INCLUDED
+#define Data_MySQL_Extractor_INCLUDED
+
+
+#include "Poco/Data/MySQL/MySQL.h"
+#include "Poco/Data/MySQL/StatementExecutor.h"
+#include "Poco/Data/MySQL/ResultMetadata.h"
+#include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Data/LOB.h"
+
+
+namespace Poco {
+
+namespace Dynamic {
+	class Var;
+}
+
+namespace Data {
+namespace MySQL {
+
+
+class MySQL_API Extractor: public Poco::Data::AbstractExtractor
+	/// Extracts and converts data values from the result row returned by MySQL.
+	/// If NULL is received, the incoming val value is not changed and false is returned
+{
+public:
+	typedef SharedPtr<Extractor> Ptr;
+
+	Extractor(StatementExecutor& st, ResultMetadata& md);
+		/// Creates the Extractor.
+
+	virtual ~Extractor();
+		/// Destroys the Extractor.
+
+	virtual bool extract(std::size_t pos, Poco::Int8& val);
+		/// Extracts an Int8.
+
+	virtual bool extract(std::size_t pos, Poco::UInt8& val);
+		/// Extracts an UInt8.
+
+	virtual bool extract(std::size_t pos, Poco::Int16& val);
+		/// Extracts an Int16.
+
+	virtual bool extract(std::size_t pos, Poco::UInt16& val);
+		/// Extracts an UInt16.
+
+	virtual bool extract(std::size_t pos, Poco::Int32& val);
+		/// Extracts an Int32.
+
+	virtual bool extract(std::size_t pos, Poco::UInt32& val);
+		/// Extracts an UInt32.
+
+	virtual bool extract(std::size_t pos, Poco::Int64& val);
+		/// Extracts an Int64.
+
+	virtual bool extract(std::size_t pos, Poco::UInt64& val);
+		/// Extracts an UInt64.
+
+#ifndef POCO_INT64_IS_LONG
+	virtual bool extract(std::size_t pos, long& val);
+		/// Extracts a long. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, unsigned long& val);
+		/// Extracts an unsigned long. Returns false if null was received.
+#endif
+
+	virtual bool extract(std::size_t pos, bool& val);
+		/// Extracts a boolean.
+
+	virtual bool extract(std::size_t pos, float& val);
+		/// Extracts a float.
+
+	virtual bool extract(std::size_t pos, double& val);
+		/// Extracts a double.
+
+	virtual bool extract(std::size_t pos, char& val);
+		/// Extracts a single character.
+
+	virtual bool extract(std::size_t pos, std::string& val);
+		/// Extracts a string.
+
+	virtual bool extract(std::size_t pos, Poco::Data::BLOB& val);
+		/// Extracts a BLOB.
+
+	virtual bool extract(std::size_t pos, Poco::Data::CLOB& val);
+		/// Extracts a CLOB.
+
+	virtual bool extract(std::size_t pos, DateTime& val);
+		/// Extracts a DateTime. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, Date& val);
+		/// Extracts a Date. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, Time& val);
+		/// Extracts a Time. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, Any& val);
+		/// Extracts an Any. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, Dynamic::Var& val);
+		/// Extracts a Dynamic::Var. Returns false if null was received.
+
+	virtual bool isNull(std::size_t col, std::size_t row);
+		/// Returns true if the value at [col,row] position is null.
+
+	virtual void reset();
+		/// Resets any information internally cached by the extractor.
+
+	////////////
+	// Not implemented extract functions
+	////////////
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Extracts an Int8 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int8>& val);
+		/// Extracts an Int8 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int8>& val);
+		/// Extracts an Int8 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Extracts an UInt8 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt8>& val);
+		/// Extracts an UInt8 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt8>& val);
+		/// Extracts an UInt8 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Extracts an Int16 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int16>& val);
+		/// Extracts an Int16 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int16>& val);
+		/// Extracts an Int16 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Extracts an UInt16 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt16>& val);
+		/// Extracts an UInt16 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt16>& val);
+		/// Extracts an UInt16 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Extracts an Int32 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int32>& val);
+		/// Extracts an Int32 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int32>& val);
+		/// Extracts an Int32 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Extracts an UInt32 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt32>& val);
+		/// Extracts an UInt32 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt32>& val);
+		/// Extracts an UInt32 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Extracts an Int64 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int64>& val);
+		/// Extracts an Int64 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int64>& val);
+		/// Extracts an Int64 list.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Extracts an UInt64 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt64>& val);
+		/// Extracts an UInt64 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt64>& val);
+		/// Extracts an UInt64 list.
+
+#ifndef POCO_INT64_IS_LONG
+	virtual bool extract(std::size_t pos, std::vector<long>& val);
+		/// Extracts a long vector.
+
+	virtual bool extract(std::size_t pos, std::deque<long>& val);
+		/// Extracts a long deque.
+
+	virtual bool extract(std::size_t pos, std::list<long>& val);
+		/// Extracts a long list.
+#endif
+
+	virtual bool extract(std::size_t pos, std::vector<bool>& val);
+		/// Extracts a boolean vector.
+
+	virtual bool extract(std::size_t pos, std::deque<bool>& val);
+		/// Extracts a boolean deque.
+
+	virtual bool extract(std::size_t pos, std::list<bool>& val);
+		/// Extracts a boolean list.
+
+	virtual bool extract(std::size_t pos, std::vector<float>& val);
+		/// Extracts a float vector.
+
+	virtual bool extract(std::size_t pos, std::deque<float>& val);
+		/// Extracts a float deque.
+
+	virtual bool extract(std::size_t pos, std::list<float>& val);
+		/// Extracts a float list.
+
+	virtual bool extract(std::size_t pos, std::vector<double>& val);
+		/// Extracts a double vector.
+
+	virtual bool extract(std::size_t pos, std::deque<double>& val);
+		/// Extracts a double deque.
+
+	virtual bool extract(std::size_t pos, std::list<double>& val);
+		/// Extracts a double list.
+
+	virtual bool extract(std::size_t pos, std::vector<char>& val);
+		/// Extracts a character vector.
+
+	virtual bool extract(std::size_t pos, std::deque<char>& val);
+		/// Extracts a character deque.
+
+	virtual bool extract(std::size_t pos, std::list<char>& val);
+		/// Extracts a character list.
+
+	virtual bool extract(std::size_t pos, std::vector<std::string>& val);
+		/// Extracts a string vector.
+
+	virtual bool extract(std::size_t pos, std::deque<std::string>& val);
+		/// Extracts a string deque.
+
+	virtual bool extract(std::size_t pos, std::list<std::string>& val);
+		/// Extracts a string list.
+
+	virtual bool extract(std::size_t pos, std::vector<BLOB>& val);
+		/// Extracts a BLOB vector.
+
+	virtual bool extract(std::size_t pos, std::deque<BLOB>& val);
+		/// Extracts a BLOB deque.
+
+	virtual bool extract(std::size_t pos, std::list<BLOB>& val);
+		/// Extracts a BLOB list.
+
+	virtual bool extract(std::size_t pos, std::vector<CLOB>& val);
+		/// Extracts a CLOB vector.
+
+	virtual bool extract(std::size_t pos, std::deque<CLOB>& val);
+		/// Extracts a CLOB deque.
+
+	virtual bool extract(std::size_t pos, std::list<CLOB>& val);
+		/// Extracts a CLOB list.
+
+	virtual bool extract(std::size_t pos, std::vector<DateTime>& val);
+		/// Extracts a DateTime vector.
+
+	virtual bool extract(std::size_t pos, std::deque<DateTime>& val);
+		/// Extracts a DateTime deque.
+
+	virtual bool extract(std::size_t pos, std::list<DateTime>& val);
+		/// Extracts a DateTime list.
+
+	virtual bool extract(std::size_t pos, std::vector<Date>& val);
+		/// Extracts a Date vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Date>& val);
+		/// Extracts a Date deque.
+
+	virtual bool extract(std::size_t pos, std::list<Date>& val);
+		/// Extracts a Date list.
+
+	virtual bool extract(std::size_t pos, std::vector<Time>& val);
+		/// Extracts a Time vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Time>& val);
+		/// Extracts a Time deque.
+
+	virtual bool extract(std::size_t pos, std::list<Time>& val);
+		/// Extracts a Time list.
+
+	virtual bool extract(std::size_t pos, std::vector<Any>& val);
+		/// Extracts an Any vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Any>& val);
+		/// Extracts an Any deque.
+
+	virtual bool extract(std::size_t pos, std::list<Any>& val);
+		/// Extracts an Any list.
+
+	virtual bool extract(std::size_t pos, std::vector<Dynamic::Var>& val);
+		/// Extracts a Dynamic::Var vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Dynamic::Var>& val);
+		/// Extracts a Dynamic::Var deque.
+
+	virtual bool extract(std::size_t pos, std::list<Dynamic::Var>& val);
+		/// Extracts a Dynamic::Var list.
+
+private:
+	bool realExtractFixed(std::size_t pos, enum_field_types type, void* buffer, bool isUnsigned = false);
+
+	// Prevent VC8 warning "operator= could not be generated"
+	Extractor& operator=(const Extractor&);
+
+private:
+	StatementExecutor& _stmt;
+	ResultMetadata& _metadata;
+};
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif // Data_MySQL_Extractor_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/MySQL.h

@@ -0,0 +1,61 @@
+//
+// MySQL.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  MySQL
+//
+// Basic definitions for the MySQL library.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MySQL_MySQL_INCLUDED
+#define MySQL_MySQL_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the ODBC_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// ODBC_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(MySQL_EXPORTS)
+		#define MySQL_API __declspec(dllexport)
+	#else
+		#define MySQL_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(MySQL_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define MySQL_API __attribute__ ((visibility ("default")))
+	#else
+		#define MySQL_API
+	#endif
+#endif
+
+
+//
+// Automatically link Data library.
+//
+#if defined(_MSC_VER) && !defined(POCO_NO_AUTOMATIC_LIBS)
+	#if !defined(MySQL_EXPORTS)
+		#pragma comment(lib, "PocoDataMySQL" POCO_LIB_SUFFIX)
+	#endif
+	#pragma comment(lib, "libmysql")
+#endif
+
+
+#endif // MySQL_MySQL_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/MySQLException.h

@@ -0,0 +1,154 @@
+//
+// MySQLException.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  MySQLException
+//
+// Definition of the MySQLException class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_MySQLException_INCLUDED
+#define Data_MySQL_MySQLException_INCLUDED
+
+
+#include "Poco/Data/MySQL/MySQL.h"
+#include "Poco/Data/DataException.h"
+#include <typeinfo>
+#include <string>
+#include <mysql.h>
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+// End-user include this file and use in code ConnectionException/StatementException
+// So it need not know
+
+
+class MySQL_API MySQLException: public Poco::Data::DataException
+	/// Base class for all MySQL exceptions
+{
+public:
+	MySQLException(const std::string& msg);
+		/// Creates MySQLException.
+
+	MySQLException(const MySQLException& exc);
+		/// Creates MySQLException.
+
+	MySQLException(const std::string& msg, int code);
+		/// Creates MySQLException.
+
+	~MySQLException() noexcept;
+		/// Destroys MySQLexception.
+
+	MySQLException& operator=(const MySQLException& exc);
+		/// Assignment operator.
+
+	const char* name() const noexcept;
+		/// Returns exception name.
+
+	const char* className() const noexcept;
+		/// Returns the name of the exception class.
+
+	Poco::Exception* clone() const;
+		/// Creates an exact copy of the exception.
+		///
+		/// The copy can later be thrown again by
+		/// invoking rethrow() on it.
+
+	void rethrow() const;
+		/// (Re)Throws the exception.
+		///
+		/// This is useful for temporarily storing a
+		/// copy of an exception (see clone()), then
+		/// throwing it again.
+};
+
+
+class ConnectionException : public MySQLException
+	/// ConnectionException
+{
+public:
+	ConnectionException(const std::string& msg);
+		/// Creates ConnectionException from string.
+
+	ConnectionException(const std::string& text, MYSQL* h);
+		/// Creates ConnectionException from string and handle.
+
+private:
+	static std::string compose(const std::string& text, MYSQL* h);
+};
+
+
+class TransactionException : public ConnectionException
+	/// TrabsactionException
+{
+public:
+	TransactionException(const std::string& msg);
+		/// Creates TransactionException from string.
+
+	TransactionException(const std::string& text, MYSQL* h);
+		/// Creates TransactionException from string and handle.
+};
+
+
+class StatementException : public MySQLException
+	/// StatementException
+{
+public:
+	StatementException(const std::string& msg);
+		/// Creates StatementException from string.
+
+	StatementException(const std::string& text, MYSQL_STMT* h, const std::string& stmt = "");
+		/// Creates StatementException from string and handle.
+
+private:
+	static std::string compose(const std::string& text, MYSQL_STMT* h, const std::string& stmt);
+};
+
+
+//
+// inlines
+//
+
+
+inline MySQLException& MySQLException::operator=(const MySQLException& exc)
+{
+	Poco::Data::DataException::operator=(exc);
+	return *this;
+}
+
+inline const char* MySQLException::name() const noexcept
+{
+	return "MySQL";
+}
+
+inline const char* MySQLException::className() const noexcept
+{
+	return typeid(*this).name();
+}
+
+inline Poco::Exception* MySQLException::clone() const
+{
+	return new MySQLException(*this);
+}
+
+inline void MySQLException::rethrow() const
+{
+	throw *this;
+}
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif //Data_MySQL_MySQLException_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/MySQLStatementImpl.h

@@ -0,0 +1,102 @@
+//
+// MySQLstatementImpl.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  MySQLstatementImpl
+//
+// Definition of the MySQLStatementImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_MySQLStatementImpl_INCLUDED
+#define Data_MySQL_MySQLStatementImpl_INCLUDED
+
+
+#include "Poco/Data/MySQL/MySQL.h"
+#include "Poco/Data/MySQL/SessionImpl.h"
+#include "Poco/Data/MySQL/Binder.h"
+#include "Poco/Data/MySQL/Extractor.h"
+#include "Poco/Data/MySQL/StatementExecutor.h"
+#include "Poco/Data/MySQL/ResultMetadata.h"
+#include "Poco/Data/StatementImpl.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Format.h"
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+class MySQL_API MySQLStatementImpl: public Poco::Data::StatementImpl
+	/// Implements statement functionality needed for MySQL
+{
+public:
+	MySQLStatementImpl(SessionImpl& s);
+		/// Creates the MySQLStatementImpl.
+		
+	~MySQLStatementImpl();
+		/// Destroys the MySQLStatementImpl.
+		
+protected:
+	virtual std::size_t columnsReturned() const;
+		/// Returns number of columns returned by query.
+
+	virtual int affectedRowCount() const;
+		/// Returns the number of affected rows.
+		/// Used to find out the number of rows affected by insert, delete or update.
+	
+	virtual const MetaColumn& metaColumn(std::size_t pos) const;
+		/// Returns column meta data.
+		
+	virtual bool hasNext();
+		/// Returns true if a call to next() will return data.
+		
+	virtual std::size_t next();
+		/// Retrieves the next row from the resultset.
+		/// Will throw, if the resultset is empty.
+	
+	virtual bool canBind() const;
+		/// Returns true if a valid statement is set and we can bind.
+
+	virtual bool canCompile() const;
+		/// Returns true if another compile is possible.
+		
+	virtual void compileImpl();
+		/// Compiles the statement, doesn't bind yet
+		
+	virtual void bindImpl();
+		/// Binds parameters
+		
+	virtual Poco::Data::AbstractExtractor::Ptr extractor();
+		/// Returns the concrete extractor used by the statement.
+		
+	virtual Poco::Data::AbstractBinder::Ptr binder();
+		/// Returns the concrete binder used by the statement.
+
+private:
+	enum
+	{
+		NEXT_DONTKNOW,
+		NEXT_TRUE,
+		NEXT_FALSE
+	};
+
+	StatementExecutor _stmt;
+	ResultMetadata    _metadata;
+	Binder::Ptr       _pBinder;
+	Extractor::Ptr    _pExtractor;
+	int               _hasNext;
+};
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif // Data_MySQL_MySQLStatementImpl_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/ResultMetadata.h

@@ -0,0 +1,79 @@
+//
+// ResultMetadata.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  ResultMetadata
+//
+// Definition of the ResultMetadata class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_ResultMetadata_INCLUDED
+#define Data_MySQL_ResultMetadata_INCLUDED
+
+
+#include <mysql.h>
+#include <vector>
+#include "Poco/Data/MetaColumn.h"
+
+
+#if LIBMYSQL_VERSION_ID >= 80000
+typedef bool my_bool;  // Workaround to make library work with MySQL client 8.0 as well as earlier versions
+typedef char my_boolv; // Workaround for std::vector<bool>
+#else
+typedef my_bool my_boolv;
+#endif
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+class ResultMetadata
+	/// MySQL result metadata
+{
+public:
+	void reset();
+		/// Resets the metadata.
+
+	void init(MYSQL_STMT* stmt);
+		/// Initializes the metadata.
+
+	std::size_t columnsReturned() const;
+		/// Returns the number of columns in resultset.
+
+	const MetaColumn& metaColumn(std::size_t pos) const;
+		/// Returns the reference to the specified metacolumn.
+
+	MYSQL_BIND* row();
+		/// Returns pointer to native row.
+
+	std::size_t length(std::size_t pos) const;
+		/// Returns the length.
+
+	const unsigned char* rawData(std::size_t pos) const;
+		/// Returns raw data.
+
+	bool isNull(std::size_t pos) const;
+		/// Returns true if value at pos is null.
+
+private:
+	std::vector<MetaColumn>    _columns;
+	std::vector<MYSQL_BIND>    _row;
+	std::vector<char>          _buffer;
+	std::vector<unsigned long> _lengths;
+	std::vector<my_boolv>      _isNull; // using char instead of bool to avoid std::vector<bool> disaster
+};
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif //Data_MySQL_ResultMetadata_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/SessionHandle.h

@@ -0,0 +1,100 @@
+//
+// SesssionHandle.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  SessionHandle
+//
+// Definition of the SessionHandle class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_SessionHandle_INCLUDED
+#define Data_MySQL_SessionHandle_INCLUDED
+
+
+#include <mysql.h>
+#include "Poco/Data/MySQL/MySQLException.h"
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+class SessionHandle
+	/// MySQL session handle
+{
+public:
+	explicit SessionHandle(MYSQL* mysql);
+		/// Creates session handle
+
+	~SessionHandle();
+		/// Destroy handle, close connection
+
+	void init(MYSQL* mysql = 0);
+		/// Initializes the handle iff not initialized.
+
+	void options(mysql_option opt);
+		/// Set connection options
+
+	void options(mysql_option opt, bool b);
+		/// Set connection options
+
+	void options(mysql_option opt, const char* c);
+		/// Set connection options
+
+	void options(mysql_option opt, unsigned int i);
+		/// Set connection options
+
+	void connect(const char* host, const char* user, const char* password, const char* db, unsigned int port);
+		/// Connect to server
+
+	void close();
+		/// Close connection
+
+	void startTransaction();
+		/// Start transaction
+
+	void commit();
+		/// Commit transaction
+
+	void rollback();
+		/// Rollback transaction
+
+	void reset();
+		/// Reset connection with dababase and clears session state, but without disconnecting
+
+	bool ping();
+		/// Checks if the connection is alive.
+
+	operator MYSQL* ();
+
+private:
+	SessionHandle(const SessionHandle&);
+	SessionHandle& operator=(const SessionHandle&);
+
+private:
+	MYSQL* _pHandle;
+};
+
+
+//
+// inlines
+//
+
+inline SessionHandle::operator MYSQL* ()
+{
+	return _pHandle;
+}
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif // Data_MySQL_SessionHandle_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/SessionImpl.h

@@ -0,0 +1,294 @@
+//
+// SessionImpl.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  SessionImpl
+//
+// Definition of the SessionImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_SessionImpl_INCLUDED
+#define Data_MySQL_SessionImpl_INCLUDED
+
+
+#include "Poco/Data/MySQL/MySQL.h"
+#include "Poco/Data/AbstractSessionImpl.h"
+#include "Poco/Data/MySQL/SessionHandle.h"
+#include "Poco/Data/MySQL/StatementExecutor.h"
+#include "Poco/Data/MySQL/ResultMetadata.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+class MySQL_API SessionImpl: public Poco::Data::AbstractSessionImpl<SessionImpl>
+	/// Implements SessionImpl interface
+{
+public:
+	static const std::string MYSQL_READ_UNCOMMITTED;
+	static const std::string MYSQL_READ_COMMITTED;
+	static const std::string MYSQL_REPEATABLE_READ;
+	static const std::string MYSQL_SERIALIZABLE;
+
+	SessionImpl(const std::string& connectionString, std::size_t loginTimeout = LOGIN_TIMEOUT_DEFAULT);
+		/// Creates the SessionImpl. Opens a connection to the database.
+		///
+		/// Connection string format:
+		///     <str> == <assignment> | <assignment> ';' <str>
+		///     <assignment> == <name> '=' <value>
+		///     <name> == 'host' | 'port' | 'user' | 'password' | 'db' | 'compress' | 'auto-reconnect' | 'reset' | 'fail-readonly'
+		///     <value> == [~;]*
+		///
+		/// The following settings are supported:
+		///   - host: MySQL server hostname or IP address (default: localhost)
+		///   - port: MySQL server port number (default: 3306)
+		///   - user: MySQL user name
+		///   - password: MySQL password
+		///   - compress: enable compression (true/false; default: false)
+		///   - auto-reconnect: enable automatic reconnect (true/false; default: false)
+		///   - secure-auth: use secure authentication (true/false; default: false)
+		///   - character-set: connection character set (default: utf8)
+		///   - reset: reset connection when returned to SessionPool by calling
+		///     mysql_reset_connection().
+		///   - fail-readonly: if set to true, the session will fail
+		///     if the database becomes read-only. This corresponds to
+		///     setFailIfInnoReadOnly(true).
+		///
+		/// Warning: Due to a bug in MySQL, resetting the connection with mysql_reset_connection()
+		/// could change the character encoding used for the connection. Therefore the
+		/// reset option should be used with caution.
+
+	~SessionImpl();
+		/// Destroys the SessionImpl.
+
+	Poco::SharedPtr<Poco::Data::StatementImpl> createStatementImpl();
+		/// Returns an MySQL StatementImpl
+
+	void open(const std::string& connection = "");
+		/// Opens a connection to the database.
+
+	void close();
+		/// Closes the connection.
+
+	void reset();
+		/// Reset connection with dababase and clears session state, but without disconnecting
+
+	bool isConnected() const;
+		/// Returns true if connected, false otherwise.
+
+	bool isGood() const;
+		/// Returns true iff the database session is good.
+		/// For the session to be considered good:
+		///   - it must be connected
+		///   - and it's last error code must be 0,
+		///     or mysql_ping() must be okay.
+		///
+		/// Furthermore, if the "failIfInnoReadOnly" property
+		/// has been set to true, the innodb_read_only setting
+		/// must be false. The flag is only checked if the
+		/// session has a non-zero error code.
+
+	void setConnectionTimeout(std::size_t timeout);
+		/// Sets the session connection timeout value.
+
+	std::size_t getConnectionTimeout() const;
+		/// Returns the session connection timeout value.
+
+	void begin();
+		/// Starts a transaction
+
+	void commit();
+		/// Commits and ends a transaction
+
+	void rollback();
+		/// Aborts a transaction
+
+	bool canTransact() const;
+		/// Returns true if session has transaction capabilities.
+
+	bool isTransaction() const;
+		/// Returns true iff a transaction is a transaction is in progress, false otherwise.
+
+	void setTransactionIsolation(Poco::UInt32 ti);
+		/// Sets the transaction isolation level.
+
+	Poco::UInt32 getTransactionIsolation() const;
+		/// Returns the transaction isolation level.
+
+	bool hasTransactionIsolation(Poco::UInt32 ti) const;
+		/// Returns true iff the transaction isolation level corresponding
+		/// to the supplied bitmask is supported.
+
+	bool isTransactionIsolation(Poco::UInt32 ti) const;
+		/// Returns true iff the transaction isolation level corresponds
+		/// to the supplied bitmask.
+
+	void autoCommit(const std::string&, bool val);
+		/// Sets autocommit property for the session.
+
+	bool isAutoCommit(const std::string& name="") const;
+		/// Returns autocommit property value.
+
+	void setInsertId(const std::string&, const Poco::Any&);
+		/// Try to set insert id - do nothing.
+
+	Poco::Any getInsertId(const std::string&) const;
+		/// Get insert id
+
+	void setFailIfInnoReadOnly(const std::string&, bool value);
+		/// Sets the "failIfInnoReadOnly" feature. If set, isGood() will
+		/// return false if the database is in read-only mode.
+
+	bool getFailIfInnoReadOnly(const std::string&) const;
+		/// Returns the state of the "failIfInnoReadOnly" feature.
+
+	void setLastError(int err);
+		/// Sets an error code. If a non-zero error code is set, the session
+		/// is considered bad.
+
+	int getLastError() const;
+		/// Returns the last set error code.
+
+	SessionHandle& handle();
+		// Get handle
+
+	const std::string& connectorName() const;
+		/// Returns the name of the connector.
+
+private:
+	template <typename T>
+	static inline T& getValue(MYSQL_BIND* pResult, T& val)
+	{
+		return val = *((T*) pResult->buffer);
+	}
+
+	template <typename T>
+	T& getSetting(const std::string& name, T& val) const
+		/// Returns required setting.
+		/// Limited to one setting at a time.
+	{
+		StatementExecutor ex(_handle);
+		ResultMetadata metadata;
+		metadata.reset();
+		ex.prepare(Poco::format("SELECT @@%s", name));
+		metadata.init(ex);
+
+		if (metadata.columnsReturned() > 0)
+			ex.bindResult(metadata.row());
+		else
+			throw InvalidArgumentException("No data returned.");
+
+		ex.execute(); ex.fetch();
+		MYSQL_BIND* pResult = metadata.row();
+		return getValue<T>(pResult, val);
+	}
+
+	std::string           _connector;
+	mutable SessionHandle _handle;
+	bool                  _reset;
+	bool                  _connected;
+	bool                  _inTransaction;
+	bool                  _failIfInnoReadOnly;
+	std::size_t           _timeout;
+	mutable int           _lastError;
+	Poco::FastMutex       _mutex;
+};
+
+
+//
+// inlines
+//
+inline bool SessionImpl::canTransact() const
+{
+	return true;
+}
+
+
+inline void SessionImpl::setInsertId(const std::string&, const Poco::Any&)
+{
+}
+
+
+inline Poco::Any SessionImpl::getInsertId(const std::string&) const
+{
+	return Poco::Any(Poco::UInt64(mysql_insert_id(_handle)));
+}
+
+
+inline void SessionImpl::setFailIfInnoReadOnly(const std::string&, bool value)
+{
+	_failIfInnoReadOnly = value;
+}
+
+
+inline bool SessionImpl::getFailIfInnoReadOnly(const std::string&) const
+{
+	return _failIfInnoReadOnly;
+}
+
+
+inline void SessionImpl::setLastError(int err)
+{
+	_lastError = err;
+}
+
+
+inline int SessionImpl::getLastError() const
+{
+	return _lastError;
+}
+
+
+inline SessionHandle& SessionImpl::handle()
+{
+	return _handle;
+}
+
+
+inline const std::string& SessionImpl::connectorName() const
+{
+	return _connector;
+}
+
+
+inline bool SessionImpl::isTransaction() const
+{
+	return _inTransaction;
+}
+
+
+inline bool SessionImpl::isTransactionIsolation(Poco::UInt32 ti) const
+{
+	return getTransactionIsolation() == ti;
+}
+
+
+inline std::size_t SessionImpl::getConnectionTimeout() const
+{
+	return _timeout;
+}
+
+
+template <>
+inline std::string& SessionImpl::getValue(MYSQL_BIND* pResult, std::string& val)
+{
+	val.assign((char*) pResult->buffer, pResult->buffer_length);
+	return val;
+}
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif // Data_MySQL_SessionImpl_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/StatementExecutor.h

@@ -0,0 +1,99 @@
+//
+// StatementExecutor.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  StatementExecutor
+//
+// Definition of the StatementExecutor class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MySQL_StatementHandle_INCLUDED
+#define Data_MySQL_StatementHandle_INCLUDED
+
+
+#include <mysql.h>
+#include "Poco/Data/MySQL/MySQLException.h"
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+class StatementExecutor
+	/// MySQL statement executor.
+{
+public:
+	enum State
+	{
+		STMT_INITED,
+		STMT_COMPILED,
+		STMT_EXECUTED
+	};
+
+	explicit StatementExecutor(MYSQL* mysql);
+		/// Creates the StatementExecutor.
+
+	~StatementExecutor();
+		/// Destroys the StatementExecutor.
+
+	int state() const;
+		/// Returns the current state.
+
+	void prepare(const std::string& query);
+		/// Prepares the statement for execution.
+
+	void bindParams(MYSQL_BIND* params, std::size_t count);
+		/// Binds the params.
+
+	void bindResult(MYSQL_BIND* result);
+		/// Binds result.
+
+	void execute();
+		/// Executes the statement.
+
+	bool fetch();
+		/// Fetches the data.
+
+	bool fetchColumn(std::size_t n, MYSQL_BIND *bind);
+		/// Fetches the column.
+
+	int getAffectedRowCount() const;
+		
+	operator MYSQL_STMT* ();
+		/// Cast operator to native handle type.
+
+private:
+	StatementExecutor(const StatementExecutor&);
+	StatementExecutor& operator=(const StatementExecutor&);
+
+private:
+	MYSQL*      _pSessionHandle;
+	MYSQL_STMT* _pHandle;
+	int         _state;
+	std::size_t _affectedRowCount;
+	std::string _query;
+};
+
+
+//
+// inlines
+//
+
+inline StatementExecutor::operator MYSQL_STMT* ()
+{
+	return _pHandle;
+}
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif // Data_MySQL_StatementHandle_INCLUDED

vendor/POCO/Data/MySQL/include/Poco/Data/MySQL/Utility.h

@@ -0,0 +1,75 @@
+//
+// Utility.h
+//
+// Library: Data/MySQL
+// Package: MySQL
+// Module:  Utility
+//
+// Definition of Utility.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MySQL_Utility_INCLUDED
+#define MySQL_Utility_INCLUDED
+
+
+#include "Poco/Data/MySQL/MySQL.h"
+#include "Poco/Data/Session.h"
+#include <mysql.h>
+
+
+namespace Poco {
+namespace Data {
+namespace MySQL {
+
+
+class MySQL_API Utility
+	/// Various utility functions for MySQL.
+{
+public:
+	static std::string serverInfo(MYSQL* pHandle);
+		/// Returns server info.
+
+	static std::string serverInfo(Poco::Data::Session& session);
+		/// Returns server info.
+
+	static unsigned long serverVersion(MYSQL* pHandle);
+		/// Returns server version.
+
+	static unsigned long serverVersion(Poco::Data::Session& session);
+		/// Returns server version.
+
+	static std::string hostInfo(MYSQL* pHandle);
+		/// Returns host info.
+
+	static std::string hostInfo(Poco::Data::Session& session);
+		/// Returns host info.
+
+	static bool hasMicrosecond();
+		/// Rturns true if microseconds are suported.
+
+	static MYSQL* handle(Poco::Data::Session& session);
+		/// Returns native MySQL handle for the session.
+};
+
+
+//
+// inlines
+//
+
+
+inline MYSQL* Utility::handle(Session& session)
+{
+	return Poco::AnyCast<MYSQL*>(session.getProperty("handle"));
+}
+
+
+} } } // namespace Poco::Data::MySQL
+
+
+#endif // MySQL_Utility_INCLUDED