From a42e8d919b09c64cb4c0b2aeede610b376728dda Mon Sep 17 00:00:00 2001 From: Aleksandar Fabijanic Date: Mon, 24 Nov 2008 00:38:23 +0000 Subject: [PATCH] [SF 2272430] BLOB and CLOB Renamed: (Abstract)Preparation => (Abstract)Preparator (Abstract)Prepare => (Abstract)Preparation --- Data/Data_VS71.vcproj | 22 +- Data/Data_VS80.vcproj | 30 +- Data/Data_VS90.vcproj | 28 +- Data/Makefile | 4 +- Data/MySQL/include/Poco/Data/MySQL/Binder.h | 19 +- .../MySQL/include/Poco/Data/MySQL/Extractor.h | 43 +- .../Poco/Data/MySQL/MySQLStatementImpl.h | 6 +- .../include/Poco/Data/MySQL/ResultMetadata.h | 2 +- Data/MySQL/src/Binder.cpp | 307 +++++----- Data/MySQL/src/Extractor.cpp | 318 +++++----- Data/MySQL/src/ResultMetadata.cpp | 24 +- Data/MySQL/testsuite/src/MySQLTest.cpp | 2 +- Data/MySQL/testsuite/src/SQLExecutor.cpp | 14 +- Data/ODBC/Makefile | 2 +- Data/ODBC/ODBC_VS71.vcproj | 34 +- Data/ODBC/ODBC_VS80.vcproj | 4 +- Data/ODBC/include/Poco/Data/ODBC/Binder.h | 92 ++- Data/ODBC/include/Poco/Data/ODBC/Extractor.h | 182 +++++- .../Poco/Data/ODBC/ODBCStatementImpl.h | 10 +- .../Data/ODBC/{Preparation.h => Preparator.h} | 312 ++++++---- Data/ODBC/src/Binder.cpp | 36 +- Data/ODBC/src/Extractor.cpp | 374 +++++------- Data/ODBC/src/ODBCStatementImpl.cpp | 20 +- .../src/{Preparation.cpp => Preparator.cpp} | 63 +- Data/ODBC/testsuite/src/ODBCAccessTest.cpp | 2 +- Data/ODBC/testsuite/src/ODBCDB2Test.cpp | 2 +- Data/ODBC/testsuite/src/ODBCMySQLTest.cpp | 2 +- Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp | 8 +- Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp | 2 +- Data/ODBC/testsuite/src/ODBCTest.cpp | 16 +- Data/ODBC/testsuite/src/SQLExecutor.cpp | 22 +- Data/ODBC/testsuite/src/SQLExecutor.h | 16 +- Data/SQLite/include/Poco/Data/SQLite/Binder.h | 31 +- .../include/Poco/Data/SQLite/Extractor.h | 29 +- Data/SQLite/src/Binder.cpp | 13 - Data/SQLite/src/Extractor.cpp | 14 +- Data/SQLite/testsuite/src/SQLiteTest.cpp | 14 +- Data/SQLite/testsuite/src/SQLiteTest.h | 2 +- Data/include/Poco/Data/AbstractBinder.h | 14 +- Data/include/Poco/Data/AbstractExtraction.h | 6 +- Data/include/Poco/Data/AbstractExtractor.h | 14 +- Data/include/Poco/Data/AbstractPreparation.h | 324 +--------- Data/include/Poco/Data/AbstractPreparator.h | 391 ++++++++++++ Data/include/Poco/Data/AbstractPrepare.h | 87 --- Data/include/Poco/Data/BLOB.h | 284 --------- Data/include/Poco/Data/BLOBStream.h | 123 ---- Data/include/Poco/Data/BulkExtraction.h | 6 +- Data/include/Poco/Data/Extraction.h | 38 +- Data/include/Poco/Data/MetaColumn.h | 1 + .../Poco/Data/{Prepare.h => Preparation.h} | 80 +-- Data/include/Poco/Data/RecordSet.h | 14 +- Data/include/Poco/Data/TypeHandler.h | 562 +++++++++--------- Data/src/AbstractBinder.cpp | 20 +- Data/src/AbstractExtractor.cpp | 18 + Data/src/AbstractPreparation.cpp | 370 +----------- Data/src/AbstractPreparator.cpp | 436 ++++++++++++++ Data/src/AbstractPrepare.cpp | 56 -- Data/src/BLOB.cpp | 87 --- Data/src/BLOBStream.cpp | 131 ---- Data/src/RecordSet.cpp | 1 + Data/src/StatementImpl.cpp | 2 +- Data/testsuite/Makefile | 2 +- Data/testsuite/TestSuite_VS71.vcproj | 8 +- Data/testsuite/TestSuite_VS80.vcproj | 4 +- Data/testsuite/TestSuite_VS90.vcproj | 4 +- Data/testsuite/src/Binder.cpp | 7 +- Data/testsuite/src/Binder.h | 3 + Data/testsuite/src/DataTest.cpp | 76 ++- Data/testsuite/src/DataTest.h | 9 +- Data/testsuite/src/Extractor.cpp | 8 +- Data/testsuite/src/Extractor.h | 3 + .../src/{Preparation.cpp => Preparator.cpp} | 57 +- .../src/{Preparation.h => Preparator.h} | 69 ++- Data/testsuite/src/TestStatementImpl.cpp | 2 +- Data/testsuite/src/TestStatementImpl.h | 10 +- 75 files changed, 2616 insertions(+), 2832 deletions(-) rename Data/ODBC/include/Poco/Data/ODBC/{Preparation.h => Preparator.h} (67%) rename Data/ODBC/src/{Preparation.cpp => Preparator.cpp} (73%) create mode 100644 Data/include/Poco/Data/AbstractPreparator.h delete mode 100644 Data/include/Poco/Data/AbstractPrepare.h delete mode 100644 Data/include/Poco/Data/BLOB.h delete mode 100644 Data/include/Poco/Data/BLOBStream.h rename Data/include/Poco/Data/{Prepare.h => Preparation.h} (61%) create mode 100644 Data/src/AbstractPreparator.cpp delete mode 100644 Data/src/AbstractPrepare.cpp delete mode 100644 Data/src/BLOB.cpp delete mode 100644 Data/src/BLOBStream.cpp rename Data/testsuite/src/{Preparation.cpp => Preparator.cpp} (52%) rename Data/testsuite/src/{Preparation.h => Preparator.h} (67%) diff --git a/Data/Data_VS71.vcproj b/Data/Data_VS71.vcproj index 355e4c9f4..39d2916be 100644 --- a/Data/Data_VS71.vcproj +++ b/Data/Data_VS71.vcproj @@ -265,7 +265,7 @@ RelativePath=".\include\Poco\Data\AbstractPreparation.h"> + RelativePath=".\include\Poco\Data\AbstractPreparator.h"> @@ -276,12 +276,6 @@ - - - - @@ -315,6 +309,12 @@ + + + + @@ -389,13 +389,7 @@ RelativePath=".\src\AbstractPreparation.cpp"> - - - - + RelativePath=".\src\AbstractPreparator.cpp"> diff --git a/Data/Data_VS80.vcproj b/Data/Data_VS80.vcproj index 2a9529303..049f49a71 100644 --- a/Data/Data_VS80.vcproj +++ b/Data/Data_VS80.vcproj @@ -374,7 +374,7 @@ > - - - - @@ -437,6 +429,14 @@ RelativePath=".\include\Poco\Data\Limit.h" > + + + + @@ -446,7 +446,7 @@ > - - - - diff --git a/Data/Data_VS90.vcproj b/Data/Data_VS90.vcproj index 403bad30c..6789ff467 100644 --- a/Data/Data_VS90.vcproj +++ b/Data/Data_VS90.vcproj @@ -371,7 +371,7 @@ > - - - - @@ -438,6 +430,14 @@ RelativePath=".\include\Poco\Data\Limit.h" > + + + + @@ -539,21 +539,13 @@ > - - - - diff --git a/Data/Makefile b/Data/Makefile index bcf366c67..0ccbd0f2b 100644 --- a/Data/Makefile +++ b/Data/Makefile @@ -9,8 +9,8 @@ include $(POCO_BASE)/build/rules/global objects = AbstractBinder AbstractBinding AbstractExtraction AbstractExtractor \ - AbstractPreparation AbstractPrepare ArchiveStrategy AutoTransaction \ - Bulk Connector BLOB BLOBStream DataException Date Limit MetaColumn \ + AbstractPreparation AbstractPreparator ArchiveStrategy AutoTransaction \ + Bulk Connector DataException Date Limit MetaColumn \ PooledSessionHolder PooledSessionImpl Position \ Range RecordSet Row RowFilter RowFormatter RowIterator \ SimpleRowFormatter Session SessionFactory SessionImpl \ diff --git a/Data/MySQL/include/Poco/Data/MySQL/Binder.h b/Data/MySQL/include/Poco/Data/MySQL/Binder.h index 2dc263388..c5f9a3081 100644 --- a/Data/MySQL/include/Poco/Data/MySQL/Binder.h +++ b/Data/MySQL/include/Poco/Data/MySQL/Binder.h @@ -41,7 +41,7 @@ #include "Poco/Data/MySQL/MySQL.h" #include "Poco/Data/AbstractBinder.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/MySQL/MySQLException.h" #include @@ -104,10 +104,13 @@ public: 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. @@ -199,6 +202,12 @@ public: virtual void bind(std::size_t pos, const std::list& val, Direction dir = PD_IN); + virtual void bind(std::size_t pos, const std::vector& val, Direction dir = PD_IN); + + virtual void bind(std::size_t pos, const std::deque& val, Direction dir = PD_IN); + + virtual void bind(std::size_t pos, const std::list& val, Direction dir = PD_IN); + virtual void bind(std::size_t pos, const std::vector& val, Direction dir = PD_IN); virtual void bind(std::size_t pos, const std::deque& val, Direction dir = PD_IN); @@ -235,8 +244,8 @@ public: MYSQL_BIND* getBindArray() const; /// Return array - //void updateDates(); - /// Update linked times + //void updateDates(); + /// Update linked times private: @@ -253,7 +262,7 @@ private: private: std::vector _bindArray; - std::vector _dates; + std::vector _dates; }; diff --git a/Data/MySQL/include/Poco/Data/MySQL/Extractor.h b/Data/MySQL/include/Poco/Data/MySQL/Extractor.h index 223af444e..ba0494404 100644 --- a/Data/MySQL/include/Poco/Data/MySQL/Extractor.h +++ b/Data/MySQL/include/Poco/Data/MySQL/Extractor.h @@ -44,10 +44,15 @@ #include "Poco/Data/MySQL/StatementExecutor.h" #include "Poco/Data/MySQL/ResultMetadata.h" #include "Poco/Data/AbstractExtractor.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" namespace Poco { + +namespace Dynamic { + class Var; +} + namespace Data { namespace MySQL { @@ -100,16 +105,19 @@ public: 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. @@ -122,8 +130,8 @@ public: 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, DynamicAny& val); - /// Extracts a DynamicAny. 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. @@ -131,7 +139,7 @@ public: virtual void reset(); /// Resets any information internally cached by the extractor. - //////////// + //////////// // Not implemented extract functions //////////// @@ -272,6 +280,15 @@ public: virtual bool extract(std::size_t pos, std::list& val); /// Extracts a BLOB list. + virtual bool extract(std::size_t pos, std::vector& val); + /// Extracts a CLOB vector. + + virtual bool extract(std::size_t pos, std::deque& val); + /// Extracts a CLOB deque. + + virtual bool extract(std::size_t pos, std::list& val); + /// Extracts a CLOB list. + virtual bool extract(std::size_t pos, std::vector& val); /// Extracts a DateTime vector. @@ -308,14 +325,14 @@ public: virtual bool extract(std::size_t pos, std::list& val); /// Extracts an Any list. - virtual bool extract(std::size_t pos, std::vector& val); - /// Extracts a DynamicAny vector. + virtual bool extract(std::size_t pos, std::vector& val); + /// Extracts a Dynamic::Var vector. - virtual bool extract(std::size_t pos, std::deque& val); - /// Extracts a DynamicAny deque. + virtual bool extract(std::size_t pos, std::deque& val); + /// Extracts a Dynamic::Var deque. - virtual bool extract(std::size_t pos, std::list& val); - /// Extracts a DynamicAny list. + virtual bool extract(std::size_t pos, std::list& val); + /// Extracts a Dynamic::Var list. private: diff --git a/Data/MySQL/include/Poco/Data/MySQL/MySQLStatementImpl.h b/Data/MySQL/include/Poco/Data/MySQL/MySQLStatementImpl.h index 299804c80..921eb9255 100644 --- a/Data/MySQL/include/Poco/Data/MySQL/MySQLStatementImpl.h +++ b/Data/MySQL/include/Poco/Data/MySQL/MySQLStatementImpl.h @@ -112,9 +112,9 @@ private: }; StatementExecutor _stmt; - ResultMetadata _metadata; - Binder _binder; - Extractor _extractor; + ResultMetadata _metadata; + Binder _binder; + Extractor _extractor; int _hasNext; }; diff --git a/Data/MySQL/include/Poco/Data/MySQL/ResultMetadata.h b/Data/MySQL/include/Poco/Data/MySQL/ResultMetadata.h index a392965e0..23ab1c7f2 100644 --- a/Data/MySQL/include/Poco/Data/MySQL/ResultMetadata.h +++ b/Data/MySQL/include/Poco/Data/MySQL/ResultMetadata.h @@ -70,7 +70,7 @@ public: std::size_t length(std::size_t pos) const; /// Returns the length. - const char* rawData(std::size_t pos) const; + const unsigned char* rawData(std::size_t pos) const; /// Returns raw data. bool isNull(std::size_t pos) const; diff --git a/Data/MySQL/src/Binder.cpp b/Data/MySQL/src/Binder.cpp index 48f2cd0c3..1f14fcee1 100644 --- a/Data/MySQL/src/Binder.cpp +++ b/Data/MySQL/src/Binder.cpp @@ -45,7 +45,7 @@ namespace MySQL { Binder::Binder() { } - + Binder::~Binder() { @@ -54,56 +54,56 @@ Binder::~Binder() void Binder::bind(std::size_t pos, const Poco::Int8& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_TINY, &val, 0); } void Binder::bind(std::size_t pos, const Poco::UInt8& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_TINY, &val, 0); -} +} void Binder::bind(std::size_t pos, const Poco::Int16& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_SHORT, &val, 0); } - + void Binder::bind(std::size_t pos, const Poco::UInt16& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_SHORT, &val, 0); } - + void Binder::bind(std::size_t pos, const Poco::Int32& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_LONG, &val, 0); } - + void Binder::bind(std::size_t pos, const Poco::UInt32& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_LONG, &val, 0); } - + void Binder::bind(std::size_t pos, const Poco::Int64& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_LONGLONG, &val, 0); } - + void Binder::bind(std::size_t pos, const Poco::UInt64& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_LONGLONG, &val, 0); } @@ -111,111 +111,118 @@ void Binder::bind(std::size_t pos, const Poco::UInt64& val, Direction dir) #ifndef POCO_LONG_IS_64_BIT void Binder::bind(std::size_t pos, const long& val, Direction dir) { - poco_assert(dir == PD_IN); - realBind(pos, MYSQL_TYPE_LONGLONG, &val, 0); + poco_assert(dir == PD_IN); + realBind(pos, MYSQL_TYPE_LONGLONG, &val, 0); } #endif void Binder::bind(std::size_t pos, const bool& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_TINY, &val, 0); } void Binder::bind(std::size_t pos, const float& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_FLOAT, &val, 0); } - + void Binder::bind(std::size_t pos, const double& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_DOUBLE, &val, 0); } - + void Binder::bind(std::size_t pos, const char& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_TINY, &val, 0); } void Binder::bind(std::size_t pos, const std::string& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_STRING, val.c_str(), static_cast(val.length())); } - + void Binder::bind(std::size_t pos, const Poco::Data::BLOB& val, Direction dir) { - poco_assert(dir == PD_IN); + poco_assert(dir == PD_IN); + realBind(pos, MYSQL_TYPE_BLOB, val.rawContent(), static_cast(val.size())); +} + + +void Binder::bind(std::size_t pos, const Poco::Data::CLOB& val, Direction dir) +{ + poco_assert(dir == PD_IN); realBind(pos, MYSQL_TYPE_BLOB, val.rawContent(), static_cast(val.size())); } void Binder::bind(std::size_t pos, const DateTime& val, Direction dir) { - poco_assert(dir == PD_IN); - MYSQL_TIME mt = {0}; + poco_assert(dir == PD_IN); + MYSQL_TIME mt = {0}; - mt.year = val.year(); - mt.month = val.month(); - mt.day = val.day(); - mt.hour = val.hour(); - mt.minute = val.minute(); - mt.second = val.second(); - mt.second_part = val.millisecond(); - - mt.time_type = MYSQL_TIMESTAMP_DATETIME; - - _dates.push_back(mt); - - realBind(pos, MYSQL_TYPE_DATETIME, &_dates.back(), sizeof(mt)); + mt.year = val.year(); + mt.month = val.month(); + mt.day = val.day(); + mt.hour = val.hour(); + mt.minute = val.minute(); + mt.second = val.second(); + mt.second_part = val.millisecond(); + + mt.time_type = MYSQL_TIMESTAMP_DATETIME; + + _dates.push_back(mt); + + realBind(pos, MYSQL_TYPE_DATETIME, &_dates.back(), sizeof(mt)); } void Binder::bind(std::size_t pos, const Date& val, Direction dir) { - poco_assert(dir == PD_IN); - MYSQL_TIME mt = {0}; + poco_assert(dir == PD_IN); + MYSQL_TIME mt = {0}; - mt.year = val.year(); - mt.month = val.month(); - mt.day = val.day(); + mt.year = val.year(); + mt.month = val.month(); + mt.day = val.day(); - _dates.push_back(mt); - - realBind(pos, MYSQL_TYPE_DATE, &_dates.back(), sizeof(mt)); + _dates.push_back(mt); + + realBind(pos, MYSQL_TYPE_DATE, &_dates.back(), sizeof(mt)); } void Binder::bind(std::size_t pos, const Time& val, Direction dir) { - poco_assert(dir == PD_IN); - MYSQL_TIME mt = {0}; + poco_assert(dir == PD_IN); + MYSQL_TIME mt = {0}; - mt.hour = val.hour(); - mt.minute = val.minute(); - mt.second = val.second(); + mt.hour = val.hour(); + mt.minute = val.minute(); + mt.second = val.second(); - mt.time_type = MYSQL_TIMESTAMP_TIME; - - _dates.push_back(mt); - - realBind(pos, MYSQL_TYPE_TIME, &_dates.back(), sizeof(mt)); + mt.time_type = MYSQL_TIMESTAMP_TIME; + + _dates.push_back(mt); + + realBind(pos, MYSQL_TYPE_TIME, &_dates.back(), sizeof(mt)); } void Binder::bind(std::size_t pos, const NullData&, Direction dir) { - poco_assert(dir == PD_IN); - realBind(pos, MYSQL_TYPE_NULL, 0, 0); + poco_assert(dir == PD_IN); + realBind(pos, MYSQL_TYPE_NULL, 0, 0); } @@ -238,31 +245,31 @@ MYSQL_BIND* Binder::getBindArray() const /*void Binder::updateDates() { - for (size_t i = 0; i < _dates.size(); i++) - { - switch (_dates[i].mt.time_type) - { - case MYSQL_TIMESTAMP_DATE: - _dates[i].mt.year = _dates[i].link.date->year(); - _dates[i].mt.month = _dates[i].link.date->month(); - _dates[i].mt.day = _dates[i].link.date->day(); - break; - case MYSQL_TIMESTAMP_DATETIME: - _dates[i].mt.year = _dates[i].link.dateTime->year(); - _dates[i].mt.month = _dates[i].link.dateTime->month(); - _dates[i].mt.day = _dates[i].link.dateTime->day(); - _dates[i].mt.hour = _dates[i].link.dateTime->hour(); - _dates[i].mt.minute = _dates[i].link.dateTime->minute(); - _dates[i].mt.second = _dates[i].link.dateTime->second(); - _dates[i].mt.second_part = _dates[i].link.dateTime->millisecond(); - break; - case MYSQL_TIMESTAMP_TIME: - _dates[i].mt.hour = _dates[i].link.time->hour(); - _dates[i].mt.minute = _dates[i].link.time->minute(); - _dates[i].mt.second = _dates[i].link.time->second(); - break; - } - } + for (size_t i = 0; i < _dates.size(); i++) + { + switch (_dates[i].mt.time_type) + { + case MYSQL_TIMESTAMP_DATE: + _dates[i].mt.year = _dates[i].link.date->year(); + _dates[i].mt.month = _dates[i].link.date->month(); + _dates[i].mt.day = _dates[i].link.date->day(); + break; + case MYSQL_TIMESTAMP_DATETIME: + _dates[i].mt.year = _dates[i].link.dateTime->year(); + _dates[i].mt.month = _dates[i].link.dateTime->month(); + _dates[i].mt.day = _dates[i].link.dateTime->day(); + _dates[i].mt.hour = _dates[i].link.dateTime->hour(); + _dates[i].mt.minute = _dates[i].link.dateTime->minute(); + _dates[i].mt.second = _dates[i].link.dateTime->second(); + _dates[i].mt.second_part = _dates[i].link.dateTime->millisecond(); + break; + case MYSQL_TIMESTAMP_TIME: + _dates[i].mt.hour = _dates[i].link.time->hour(); + _dates[i].mt.minute = _dates[i].link.time->minute(); + _dates[i].mt.second = _dates[i].link.time->second(); + break; + } + } }*/ /////////////////// @@ -284,7 +291,7 @@ void Binder::realBind(std::size_t pos, enum_field_types type, const void* buffer MYSQL_BIND b = {0}; b.buffer_type = type; - b.buffer = const_cast(buffer); + b.buffer = const_cast(buffer); b.buffer_length = length; _bindArray[pos] = b; @@ -293,325 +300,343 @@ void Binder::realBind(std::size_t pos, enum_field_types type, const void* buffer void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); +} + + +void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) +{ + throw NotImplementedException(); +} + + +void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) +{ + throw NotImplementedException(); +} + + +void Binder::bind(std::size_t pos, const std::list& val, Direction dir) +{ + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - throw NotImplementedException(); + throw NotImplementedException(); } diff --git a/Data/MySQL/src/Extractor.cpp b/Data/MySQL/src/Extractor.cpp index 73a1091e3..f643e013e 100644 --- a/Data/MySQL/src/Extractor.cpp +++ b/Data/MySQL/src/Extractor.cpp @@ -53,201 +53,217 @@ Extractor::~Extractor() { } - + bool Extractor::extract(std::size_t pos, Poco::Int8& val) { - return realExtractFixed(pos, MYSQL_TYPE_TINY, &val); + return realExtractFixed(pos, MYSQL_TYPE_TINY, &val); } bool Extractor::extract(std::size_t pos, Poco::UInt8& val) { - return realExtractFixed(pos, MYSQL_TYPE_TINY, &val); + return realExtractFixed(pos, MYSQL_TYPE_TINY, &val); } - + bool Extractor::extract(std::size_t pos, Poco::Int16& val) { - return realExtractFixed(pos, MYSQL_TYPE_SHORT, &val); + return realExtractFixed(pos, MYSQL_TYPE_SHORT, &val); } bool Extractor::extract(std::size_t pos, Poco::UInt16& val) { - return realExtractFixed(pos, MYSQL_TYPE_SHORT, &val); + return realExtractFixed(pos, MYSQL_TYPE_SHORT, &val); } - + bool Extractor::extract(std::size_t pos, Poco::Int32& val) { - return realExtractFixed(pos, MYSQL_TYPE_LONG, &val); + return realExtractFixed(pos, MYSQL_TYPE_LONG, &val); } - + bool Extractor::extract(std::size_t pos, Poco::UInt32& val) { - return realExtractFixed(pos, MYSQL_TYPE_LONG, &val); + return realExtractFixed(pos, MYSQL_TYPE_LONG, &val); } - + bool Extractor::extract(std::size_t pos, Poco::Int64& val) { - return realExtractFixed(pos, MYSQL_TYPE_LONGLONG, &val); + return realExtractFixed(pos, MYSQL_TYPE_LONGLONG, &val); } - + bool Extractor::extract(std::size_t pos, Poco::UInt64& val) { - return realExtractFixed(pos, MYSQL_TYPE_LONGLONG, &val); + return realExtractFixed(pos, MYSQL_TYPE_LONGLONG, &val); } - + #ifndef POCO_LONG_IS_64_BIT bool Extractor::extract(std::size_t pos, long& val) /// Extracts a long. Returns false if null was received. { - return realExtractFixed(pos, MYSQL_TYPE_LONGLONG, &val); + return realExtractFixed(pos, MYSQL_TYPE_LONGLONG, &val); } #endif bool Extractor::extract(std::size_t pos, bool& val) { - return realExtractFixed(pos, MYSQL_TYPE_TINY, &val); + return realExtractFixed(pos, MYSQL_TYPE_TINY, &val); } - + bool Extractor::extract(std::size_t pos, float& val) { - return realExtractFixed(pos, MYSQL_TYPE_FLOAT, &val); + return realExtractFixed(pos, MYSQL_TYPE_FLOAT, &val); } bool Extractor::extract(std::size_t pos, double& val) { - return realExtractFixed(pos, MYSQL_TYPE_DOUBLE, &val); + return realExtractFixed(pos, MYSQL_TYPE_DOUBLE, &val); } bool Extractor::extract(std::size_t pos, char& val) { - return realExtractFixed(pos, MYSQL_TYPE_TINY, &val); + return realExtractFixed(pos, MYSQL_TYPE_TINY, &val); } bool Extractor::extract(std::size_t pos, std::string& val) { - if (_metadata.columnsReturned() <= pos) - throw MySQLException("Extractor: attempt to extract more paremeters, than query result contain"); - - if (_metadata.isNull(static_cast(pos))) + if (_metadata.columnsReturned() <= pos) + throw MySQLException("Extractor: attempt to extract more paremeters, than query result contain"); + + if (_metadata.isNull(static_cast(pos))) return false; - - if (_metadata.metaColumn(static_cast(pos)).type() != Poco::Data::MetaColumn::FDT_STRING) - throw MySQLException("Extractor: not a string"); - - val.assign(_metadata.rawData(pos), _metadata.length(pos)); - return true; + + if (_metadata.metaColumn(static_cast(pos)).type() != Poco::Data::MetaColumn::FDT_STRING) + throw MySQLException("Extractor: not a string"); + + val.assign(reinterpret_cast(_metadata.rawData(pos)), _metadata.length(pos)); + return true; } - + bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val) { - if (_metadata.columnsReturned() <= pos) - throw MySQLException("Extractor: attempt to extract more paremeters, than query result contain"); - - if (_metadata.isNull(static_cast(pos))) + if (_metadata.columnsReturned() <= pos) + throw MySQLException("Extractor: attempt to extract more paremeters, than query result contain"); + + if (_metadata.isNull(static_cast(pos))) return false; - - if (_metadata.metaColumn(static_cast(pos)).type() != Poco::Data::MetaColumn::FDT_BLOB) - throw MySQLException("Extractor: not a blob"); - - val.assignRaw(_metadata.rawData(pos), _metadata.length(pos)); - return true; + + if (_metadata.metaColumn(static_cast(pos)).type() != Poco::Data::MetaColumn::FDT_BLOB) + throw MySQLException("Extractor: not a blob"); + + val.assignRaw(_metadata.rawData(pos), _metadata.length(pos)); + return true; +} + + +bool Extractor::extract(std::size_t pos, Poco::Data::CLOB& val) +{ + if (_metadata.columnsReturned() <= pos) + throw MySQLException("Extractor: attempt to extract more paremeters, than query result contain"); + + if (_metadata.isNull(static_cast(pos))) + return false; + + if (_metadata.metaColumn(static_cast(pos)).type() != Poco::Data::MetaColumn::FDT_BLOB) + throw MySQLException("Extractor: not a blob"); + + val.assignRaw(reinterpret_cast(_metadata.rawData(pos)), _metadata.length(pos)); + return true; } bool Extractor::extract(std::size_t pos, DateTime& val) { - MYSQL_TIME mt = {0}; + MYSQL_TIME mt = {0}; - if (!realExtractFixed(pos, MYSQL_TYPE_DATETIME, &mt)) - return false; + if (!realExtractFixed(pos, MYSQL_TYPE_DATETIME, &mt)) + return false; - val.assign(mt.year, mt.month, mt.day, mt.hour, mt.minute, mt.second, mt.second_part, 0); - return true; + val.assign(mt.year, mt.month, mt.day, mt.hour, mt.minute, mt.second, mt.second_part, 0); + return true; } bool Extractor::extract(std::size_t pos, Date& val) { - MYSQL_TIME mt = {0}; + MYSQL_TIME mt = {0}; - if (!realExtractFixed(pos, MYSQL_TYPE_DATE, &mt)) - return false; + if (!realExtractFixed(pos, MYSQL_TYPE_DATE, &mt)) + return false; - val.assign(mt.year, mt.month, mt.day); - return true; + val.assign(mt.year, mt.month, mt.day); + return true; } bool Extractor::extract(std::size_t pos, Time& val) { - MYSQL_TIME mt = {0}; + MYSQL_TIME mt = {0}; - if (!realExtractFixed(pos, MYSQL_TYPE_TIME, &mt)) - return false; + if (!realExtractFixed(pos, MYSQL_TYPE_TIME, &mt)) + return false; - val.assign(mt.hour, mt.minute, mt.second); - return true; + val.assign(mt.hour, mt.minute, mt.second); + return true; } bool Extractor::extract(std::size_t pos, Any& val) { - return false; + return false; } -bool Extractor::extract(std::size_t pos, DynamicAny& val) +bool Extractor::extract(std::size_t pos, Dynamic::Var& val) { - return false; + return false; } bool Extractor::isNull(std::size_t col, std::size_t row) { - poco_assert(row == POCO_DATA_INVALID_ROW); + poco_assert(row == POCO_DATA_INVALID_ROW); - if (_metadata.columnsReturned() <= col) - throw MySQLException("Extractor: attempt to extract more paremeters, than query result contain"); + if (_metadata.columnsReturned() <= col) + throw MySQLException("Extractor: attempt to extract more paremeters, than query result contain"); - if (_metadata.isNull(static_cast(col))) - return true; + if (_metadata.isNull(static_cast(col))) + return true; - return false; + return false; } void Extractor::reset() { - AbstractExtractor::reset(); + AbstractExtractor::reset(); } bool Extractor::realExtractFixed(std::size_t pos, enum_field_types type, void* buffer, size_t length) { - MYSQL_BIND bind = {0}; - my_bool isNull = 0; + MYSQL_BIND bind = {0}; + my_bool isNull = 0; - bind.is_null = &isNull; - bind.buffer_type = type; - bind.buffer = buffer; - bind.buffer_length = static_cast(length); - - if (!_stmt.fetchColumn(pos, &bind)) - return false; + bind.is_null = &isNull; + bind.buffer_type = type; + bind.buffer = buffer; + bind.buffer_length = static_cast(length); + + if (!_stmt.fetchColumn(pos, &bind)) + return false; - return isNull == 0; + return isNull == 0; } @@ -258,363 +274,381 @@ bool Extractor::realExtractFixed(std::size_t pos, enum_field_types type, void* b bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } - - + + bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } #ifndef POCO_LONG_IS_64_BIT bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } #endif bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); +} + + +bool Extractor::extract(std::size_t , std::vector& ) +{ + throw NotImplementedException("std::vector extractor must be implemented."); +} + + +bool Extractor::extract(std::size_t , std::deque& ) +{ + throw NotImplementedException("std::deque extractor must be implemented."); +} + + +bool Extractor::extract(std::size_t , std::list& ) +{ + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector& ) { - throw NotImplementedException("std::vector extractor must be implemented."); + throw NotImplementedException("std::vector extractor must be implemented."); } bool Extractor::extract(std::size_t , std::deque& ) { - throw NotImplementedException("std::deque extractor must be implemented."); + throw NotImplementedException("std::deque extractor must be implemented."); } bool Extractor::extract(std::size_t , std::list& ) { - throw NotImplementedException("std::list extractor must be implemented."); + throw NotImplementedException("std::list extractor must be implemented."); } bool Extractor::extract(std::size_t , std::vector + RelativePath=".\src\Preparator.cpp"> diff --git a/Data/ODBC/ODBC_VS80.vcproj b/Data/ODBC/ODBC_VS80.vcproj index c1e6f45aa..baf5eb67c 100644 --- a/Data/ODBC/ODBC_VS80.vcproj +++ b/Data/ODBC/ODBC_VS80.vcproj @@ -406,7 +406,7 @@ > & val, Direction dir); /// Binds a BLOB vector. @@ -281,6 +284,15 @@ public: void bind(std::size_t pos, const std::list& val, Direction dir); /// Binds a BLOB list. + void bind(std::size_t pos, const std::vector& val, Direction dir); + /// Binds a CLOB vector. + + void bind(std::size_t pos, const std::deque& val, Direction dir); + /// Binds a CLOB deque. + + void bind(std::size_t pos, const std::list& val, Direction dir); + /// Binds a CLOB list. + void bind(std::size_t pos, const Date& val, Direction dir); /// Binds a Date. @@ -393,6 +405,40 @@ private: } } + template + void bindImplLOB(std::size_t pos, const L& val, Direction dir) + { + if (isOutBound(dir) || !isInBound(dir)) + throw NotImplementedException("LOB parameter type can only be inbound."); + + SQLPOINTER pVal = (SQLPOINTER) val.rawContent(); + SQLINTEGER size = (SQLINTEGER) val.size(); + + _inParams.insert(ParamMap::value_type(pVal, size)); + + SQLLEN* pLenIn = new SQLLEN; + *pLenIn = size; + + if (PB_AT_EXEC == _paramBinding) + *pLenIn = SQL_LEN_DATA_AT_EXEC(size); + + _lengthIndicator.push_back(pLenIn); + + if (Utility::isError(SQLBindParameter(_rStmt, + (SQLUSMALLINT) pos + 1, + SQL_PARAM_INPUT, + SQL_C_BINARY, + SQL_LONGVARBINARY, + (SQLUINTEGER) size, + 0, + pVal, + (SQLINTEGER) size, + _lengthIndicator.back()))) + { + throw StatementException(_rStmt, "SQLBindParameter(LOB)"); + } + } + template void bindImplVec(std::size_t pos, const std::vector& val, SQLSMALLINT cDataType, Direction dir) { @@ -553,8 +599,11 @@ private: } template - void bindImplContainerBLOB(std::size_t pos, const C& val, Direction dir) + void bindImplContainerLOB(std::size_t pos, const C& val, Direction dir) { + typedef typename C::value_type LOBType; + typedef typename LOBType::ValueType CharType; + if (isOutBound(dir) || !isInBound(dir)) throw NotImplementedException("BLOB container parameter type can only be inbound."); @@ -585,7 +634,7 @@ private: if (_charPtrs.size() <= pos) _charPtrs.resize(pos + 1, 0); - _charPtrs[pos] = (char*) std::calloc(val.size() * size, sizeof(char)); + _charPtrs[pos] = (char*) std::calloc(val.size() * size, sizeof(CharType)); poco_check_ptr (_charPtrs[pos]); std::size_t blobSize; @@ -597,7 +646,7 @@ private: blobSize = cIt->size(); if (blobSize > size) throw LengthExceededException("SQLBindParameter(std::vector)"); - std::memcpy(_charPtrs[pos] + offset, cIt->rawContent(), blobSize); + std::memcpy(_charPtrs[pos] + offset, cIt->rawContent(), blobSize * sizeof(CharType)); offset += size; } @@ -1203,22 +1252,51 @@ inline void Binder::bind(std::size_t pos, const std::list& val, Dir bindImplContainerString(pos, val, dir); } +inline void Binder::bind(std::size_t pos, const BLOB& val, Direction dir) +{ + bindImplLOB(pos, val, dir); +} + + +inline void Binder::bind(std::size_t pos, const CLOB& val, Direction dir) +{ + bindImplLOB(pos, val, dir); +} + inline void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) { - bindImplContainerBLOB(pos, val, dir); + bindImplContainerLOB(pos, val, dir); } inline void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) { - bindImplContainerBLOB(pos, val, dir); + bindImplContainerLOB(pos, val, dir); } inline void Binder::bind(std::size_t pos, const std::list& val, Direction dir) { - bindImplContainerBLOB(pos, val, dir); + bindImplContainerLOB(pos, val, dir); +} + + +inline void Binder::bind(std::size_t pos, const std::vector& val, Direction dir) +{ + bindImplContainerLOB(pos, val, dir); +} + + +inline void Binder::bind(std::size_t pos, const std::deque& val, Direction dir) +{ + bindImplContainerLOB(pos, val, dir); +} + + +inline void Binder::bind(std::size_t pos, const std::list& val, Direction dir) +{ + bindImplContainerLOB(pos, val, dir); } diff --git a/Data/ODBC/include/Poco/Data/ODBC/Extractor.h b/Data/ODBC/include/Poco/Data/ODBC/Extractor.h index 47a0bdfb7..d44990699 100644 --- a/Data/ODBC/include/Poco/Data/ODBC/Extractor.h +++ b/Data/ODBC/include/Poco/Data/ODBC/Extractor.h @@ -43,7 +43,7 @@ #include "Poco/Data/Constants.h" #include "Poco/Data/ODBC/ODBC.h" #include "Poco/Data/AbstractExtractor.h" -#include "Poco/Data/ODBC/Preparation.h" +#include "Poco/Data/ODBC/Preparator.h" #include "Poco/Data/ODBC/ODBCMetaColumn.h" #include "Poco/Data/ODBC/Error.h" #include "Poco/Data/ODBC/Utility.h" @@ -71,7 +71,7 @@ class ODBC_API Extractor: public Poco::Data::AbstractExtractor { public: Extractor(const StatementHandle& rStmt, - Preparation& rPreparation); + Preparator& rPreparator); /// Creates the Extractor. ~Extractor(); @@ -250,6 +250,9 @@ public: bool extract(std::size_t pos, Poco::Data::BLOB& val); /// Extracts a BLOB. + bool extract(std::size_t pos, Poco::Data::CLOB& val); + /// Extracts a CLOB. + bool extract(std::size_t pos, std::vector& val); /// Extracts a BLOB vector. @@ -259,6 +262,15 @@ public: bool extract(std::size_t pos, std::list& val); /// Extracts a BLOB list. + bool extract(std::size_t pos, std::vector& val); + /// Extracts a CLOB vector. + + bool extract(std::size_t pos, std::deque& val); + /// Extracts a CLOB deque. + + bool extract(std::size_t pos, std::list& val); + /// Extracts a CLOB list. + bool extract(std::size_t pos, Poco::Data::Date& val); /// Extracts a Date. @@ -319,10 +331,10 @@ public: bool extract(std::size_t pos, std::list& val); /// Extracts a DynamicAny list. - void setDataExtraction(Preparation::DataExtraction ext); + void setDataExtraction(Preparator::DataExtraction ext); /// Set data extraction mode. - Preparation::DataExtraction getDataExtraction() const; + Preparator::DataExtraction getDataExtraction() const; /// Returns data extraction mode. bool isNull(std::size_t col, std::size_t row = POCO_DATA_INVALID_ROW); @@ -354,21 +366,85 @@ private: bool extractBoundImpl(std::size_t pos, T& val) { if (isNull(pos)) return false; - poco_assert_dbg (typeid(T) == _rPreparation[pos].type()); - val = *AnyCast(&_rPreparation[pos]); + poco_assert_dbg (typeid(T) == _rPreparator[pos].type()); + val = *AnyCast(&_rPreparator[pos]); return true; } - template + bool extractBoundImpl(std::size_t pos, Poco::Data::BLOB& val); + bool extractBoundImpl(std::size_t pos, Poco::Data::CLOB& val); + + template bool extractBoundImplContainer(std::size_t pos, C& val) { typedef typename C::value_type Type; - poco_assert_dbg (typeid(std::vector) == _rPreparation[pos].type()); - std::vector& v = RefAnyCast >(_rPreparation[pos]); + poco_assert_dbg (typeid(std::vector) == _rPreparator[pos].type()); + std::vector& v = RefAnyCast >(_rPreparator[pos]); val.assign(v.begin(), v.end()); return true; } + bool extractBoundImplContainer(std::size_t pos, std::vector& values); + bool extractBoundImplContainer(std::size_t pos, std::deque& values); + bool extractBoundImplContainer(std::size_t pos, std::list& values); + bool extractBoundImplContainer(std::size_t pos, std::vector& values); + bool extractBoundImplContainer(std::size_t pos, std::deque& values); + bool extractBoundImplContainer(std::size_t pos, std::list& values); + bool extractBoundImplContainer(std::size_t pos, std::vector& values); + bool extractBoundImplContainer(std::size_t pos, std::deque& values); + bool extractBoundImplContainer(std::size_t pos, std::list& values); + + template + bool extractBoundImplContainerString(std::size_t pos, C& values) + { + typedef typename C::value_type StringType; + typedef typename C::iterator ItType; + typedef typename StringType::value_type CharType; + + CharType** pc = AnyCast(&_rPreparator[pos]); + poco_assert_dbg (pc); + poco_assert_dbg (_rPreparator.bulkSize() == values.size()); + std::size_t colWidth = columnSize(pos); + ItType it = values.begin(); + ItType end = values.end(); + for (int row = 0; it != end; ++it, ++row) + it->assign(*pc + row * colWidth, _rPreparator.actualDataSize(pos, row)); + + return true; + } + + template + bool extractBoundImplContainerLOB(std::size_t pos, C& values) + { + typedef typename C::value_type LOBType; + typedef typename LOBType::ValueType CharType; + typedef typename C::iterator ItType; + + CharType** pc = AnyCast(&_rPreparator[pos]); + poco_assert_dbg (pc); + poco_assert_dbg (_rPreparator.bulkSize() == values.size()); + std::size_t colWidth = _rPreparator.maxDataSize(pos); + ItType it = values.begin(); + ItType end = values.end(); + for (int row = 0; it != end; ++it, ++row) + it->assignRaw(*pc + row * colWidth, _rPreparator.actualDataSize(pos, row)); + + return true; + } + + template + bool extractBoundImplLOB(std::size_t pos, Poco::Data::LOB& val) + { + if (isNull(pos)) return false; + + std::size_t dataSize = _rPreparator.actualDataSize(pos); + checkDataSize(dataSize); + T* sp = AnyCast(_rPreparator[pos]); + val.assignRaw(sp, dataSize); + + return true; + } + template bool extractManualImpl(std::size_t pos, T& val, SQLSMALLINT cType) { @@ -456,6 +532,9 @@ private: case MetaColumn::FDT_BLOB: { return extAny(pos, val); } + case MetaColumn::FDT_CLOB: + { return extAny(pos, val); } + case MetaColumn::FDT_DATE: { return extAny(pos, val); } @@ -480,8 +559,8 @@ private: SQLINTEGER columnSize(std::size_t pos) const; const StatementHandle& _rStmt; - Preparation& _rPreparation; - Preparation::DataExtraction _dataExtraction; + Preparator& _rPreparator; + Preparator::DataExtraction _dataExtraction; std::vector _lengths; }; @@ -489,13 +568,86 @@ private: /// /// inlines /// -inline void Extractor::setDataExtraction(Preparation::DataExtraction ext) + +inline bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data::BLOB& val) { - _rPreparation.setDataExtraction(_dataExtraction = ext); + return extractBoundImplLOB(pos, val); } -inline Preparation::DataExtraction Extractor::getDataExtraction() const +inline bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data::CLOB& val) +{ + return extractBoundImplLOB(pos, val); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::vector& values) +{ + return extractBoundImplContainerString(pos, values); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::deque& values) +{ + return extractBoundImplContainerString(pos, values); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::list& values) +{ + return extractBoundImplContainerString(pos, values); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, + std::vector& values) +{ + return extractBoundImplContainerLOB(pos, values); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, + std::deque& values) +{ + return extractBoundImplContainerLOB(pos, values); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, + std::list& values) +{ + return extractBoundImplContainerLOB(pos, values); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, + std::vector& values) +{ + return extractBoundImplContainerLOB(pos, values); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, + std::deque& values) +{ + return extractBoundImplContainerLOB(pos, values); +} + + +inline bool Extractor::extractBoundImplContainer(std::size_t pos, + std::list& values) +{ + return extractBoundImplContainerLOB(pos, values); +} + + +inline void Extractor::setDataExtraction(Preparator::DataExtraction ext) +{ + _rPreparator.setDataExtraction(_dataExtraction = ext); +} + + +inline Preparator::DataExtraction Extractor::getDataExtraction() const { return _dataExtraction; } @@ -523,7 +675,7 @@ inline bool Extractor::isNullLengthIndicator(SQLLEN val) const inline SQLINTEGER Extractor::columnSize(std::size_t pos) const { std::size_t size = ODBCMetaColumn(_rStmt, pos).length(); - std::size_t maxSize = _rPreparation.maxDataSize(pos); + std::size_t maxSize = _rPreparator.maxDataSize(pos); if (size > maxSize) size = maxSize; return (SQLINTEGER) size; } diff --git a/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h b/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h index c16843f32..35b50b0d6 100644 --- a/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h +++ b/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h @@ -44,7 +44,7 @@ #include "Poco/Data/ODBC/SessionImpl.h" #include "Poco/Data/ODBC/Binder.h" #include "Poco/Data/ODBC/Extractor.h" -#include "Poco/Data/ODBC/Preparation.h" +#include "Poco/Data/ODBC/Preparator.h" #include "Poco/Data/ODBC/ODBCMetaColumn.h" #include "Poco/Data/StatementImpl.h" #include "Poco/Data/Column.h" @@ -117,8 +117,8 @@ private: typedef Poco::Data::AbstractBindingVec Bindings; typedef Poco::SharedPtr BinderPtr; typedef Poco::Data::AbstractExtractionVec Extractions; - typedef Poco::SharedPtr PreparationPtr; - typedef std::vector PreparationVec; + typedef Poco::SharedPtr PreparatorPtr; + typedef std::vector PreparatorVec; typedef Poco::SharedPtr ExtractorPtr; typedef std::vector ExtractorVec; typedef std::vector ColumnPtrVec; @@ -160,13 +160,13 @@ private: void getData(); - void addPreparation(); + void addPreparator(); void fillColumns(); void checkError(SQLRETURN rc, const std::string& msg=""); const SQLHDBC& _rConnection; const StatementHandle _stmt; - PreparationVec _preparations; + PreparatorVec _preparations; BinderPtr _pBinder; ExtractorVec _extractors; bool _stepCalled; diff --git a/Data/ODBC/include/Poco/Data/ODBC/Preparation.h b/Data/ODBC/include/Poco/Data/ODBC/Preparator.h similarity index 67% rename from Data/ODBC/include/Poco/Data/ODBC/Preparation.h rename to Data/ODBC/include/Poco/Data/ODBC/Preparator.h index 2ad169997..1fc2fc4be 100644 --- a/Data/ODBC/include/Poco/Data/ODBC/Preparation.h +++ b/Data/ODBC/include/Poco/Data/ODBC/Preparator.h @@ -1,13 +1,13 @@ // -// Preparation.h +// Preparator.h // -// $Id: //poco/Main/Data/ODBC/include/Poco/Data/ODBC/Preparation.h#5 $ +// $Id: //poco/Main/Data/ODBC/include/Poco/Data/ODBC/Preparator.h#5 $ // // Library: Data // Package: DataCore -// Module: Preparation +// Module: Preparator // -// Definition of the Preparation class. +// Definition of the Preparator class. // // Copyright (c) 2006, Applied Informatics Software Engineering GmbH. // and Contributors. @@ -36,8 +36,8 @@ // -#ifndef Data_ODBC_Preparation_INCLUDED -#define Data_ODBC_Preparation_INCLUDED +#ifndef Data_ODBC_Preparator_INCLUDED +#define Data_ODBC_Preparator_INCLUDED #include "Poco/Data/Constants.h" @@ -45,8 +45,8 @@ #include "Poco/Data/ODBC/Handle.h" #include "Poco/Data/ODBC/ODBCMetaColumn.h" #include "Poco/Data/ODBC/Utility.h" -#include "Poco/Data/AbstractPreparation.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/AbstractPreparator.h" +#include "Poco/Data/LOB.h" #include "Poco/Any.h" #include "Poco/DynamicAny.h" #include "Poco/DateTime.h" @@ -64,23 +64,22 @@ namespace Data { class Date; class Time; -class BLOB; namespace ODBC { -class ODBC_API Preparation : public AbstractPreparation +class ODBC_API Preparator : public AbstractPreparator /// Class used for database preparation where we first have to register all data types /// with respective memory output locations before extracting data. /// Extraction works in two-phases: first prepare is called once, then extract n-times. /// In ODBC, SQLBindCol/SQLFetch is the preferred method of data retrieval (SQLGetData is available, /// however with numerous driver implementation dependent limitations and inferior performance). /// In order to fit this functionality into Poco DataConnectors framework, every ODBC SQL statement - /// instantiates its own Preparation object. + /// instantiates its own Preparator object. /// This is done once per statement execution (from StatementImpl::bindImpl()). /// - /// Preparation object is used to : + /// Preparator object is used to : /// /// 1) Prepare SQL statement. /// 2) Provide and contain the memory locations where retrieved values are placed during recordset iteration. @@ -89,7 +88,7 @@ class ODBC_API Preparation : public AbstractPreparation /// Notes: /// /// - Value datatypes in this interface prepare() calls serve only for the purpose of type distinction. - /// - Preparation keeps its own std::vector buffer for fetched data to be later retrieved by Extractor. + /// - Preparator keeps its own std::vector buffer for fetched data to be later retrieved by Extractor. /// - prepare() methods should not be called when extraction mode is DE_MANUAL /// { @@ -107,23 +106,25 @@ public: DT_BOOL, DT_BOOL_ARRAY, DT_CHAR, + DT_UCHAR, DT_CHAR_ARRAY, + DT_UCHAR_ARRAY, DT_DATE, DT_TIME, DT_DATETIME }; - Preparation(const StatementHandle& rStmt, + Preparator(const StatementHandle& rStmt, const std::string& statement, std::size_t maxFieldSize, DataExtraction dataExtraction = DE_BOUND); - /// Creates the Preparation. + /// Creates the Preparator. - Preparation(const Preparation& other); - /// Copy constructs the Preparation. + Preparator(const Preparator& other); + /// Copy constructs the Preparator. - ~Preparation(); - /// Destroys the Preparation. + ~Preparator(); + /// Destroys the Preparator. void prepare(std::size_t pos, Poco::Int8& val); /// Prepares an Int8. @@ -307,6 +308,18 @@ public: void prepare(std::size_t pos, const std::list& val); /// Prepares a BLOB list. + void prepare(std::size_t pos, const Poco::Data::CLOB& val); + /// Prepares a CLOB. + + void prepare(std::size_t pos, const std::vector& val); + /// Prepares a CLOB vector. + + void prepare(std::size_t pos, const std::deque& val); + /// Prepares a CLOB deque. + + void prepare(std::size_t pos, const std::list& val); + /// Prepares a CLOB list. + void prepare(std::size_t pos, const Poco::Data::Date& val); /// Prepares a Date. @@ -407,8 +420,8 @@ private: typedef std::vector LengthLengthVec; typedef std::map IndexMap; - Preparation(); - Preparation& operator = (const Preparation&); + Preparator(); + Preparator& operator = (const Preparator&); template void prepareImpl(std::size_t pos, const C* pVal = 0) @@ -486,15 +499,27 @@ private: case MetaColumn::FDT_STRING: if (pVal) - return prepareCharArray(pos, SQL_C_CHAR, maxDataSize(pos), pVal->size()); + return prepareCharArray(pos, SQL_C_CHAR, maxDataSize(pos), pVal->size()); else return prepareVariableLen(pos, SQL_C_CHAR, maxDataSize(pos), DT_CHAR); case MetaColumn::FDT_BLOB: + { + typedef Poco::Data::BLOB::ValueType CharType; if (pVal) - return prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), pVal->size()); + return prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), pVal->size()); else - return prepareVariableLen(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR); + return prepareVariableLen(pos, SQL_C_BINARY, maxDataSize(pos), DT_UCHAR); + } + + case MetaColumn::FDT_CLOB: + { + typedef Poco::Data::CLOB::ValueType CharType; + if (pVal) + return prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), pVal->size()); + else + return prepareVariableLen(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR); + } case MetaColumn::FDT_DATE: if (pVal) @@ -598,9 +623,32 @@ private: } } + template + void prepareCharArray(std::size_t pos, SQLSMALLINT valueType, std::size_t size, std::size_t length) + /// Utility function for preparation of bulk variable length character and LOB columns. + { + poco_assert_dbg (DE_BOUND == _dataExtraction); + poco_assert_dbg (pos < _values.size()); + poco_assert_dbg (pos < _lengths.size()); + poco_assert_dbg (pos < _lenLengths.size()); - void prepareCharArray(std::size_t pos, SQLSMALLINT valueType, std::size_t size, std::size_t length); - /// Utility function for preparation of bulk variable length character and BLOB columns. + T* pArray = (T*) std::calloc(length * size, sizeof(T)); + + _values[pos] = Any(pArray); + _lengths[pos] = 0; + _lenLengths[pos].resize(length); + _varLengthArrays.insert(IndexMap::value_type(pos, DT)); + + if (Utility::isError(SQLBindCol(_rStmt, + (SQLUSMALLINT) pos + 1, + valueType, + (SQLPOINTER) pArray, + (SQLINTEGER) size, + &_lenLengths[pos][0]))) + { + throw StatementException(_rStmt, "SQLBindCol()"); + } + } void prepareBoolArray(std::size_t pos, SQLSMALLINT valueType, std::size_t length); /// Utility function for preparation of bulk bool columns. @@ -628,489 +676,513 @@ private: // // inlines // -inline void Preparation::prepare(std::size_t pos, Poco::Int8&) +inline void Preparator::prepare(std::size_t pos, Poco::Int8&) { prepareFixedSize(pos, SQL_C_STINYINT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_STINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_STINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_STINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, Poco::UInt8&) +inline void Preparator::prepare(std::size_t pos, Poco::UInt8&) { prepareFixedSize(pos, SQL_C_UTINYINT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_UTINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_UTINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_UTINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, Poco::Int16&) +inline void Preparator::prepare(std::size_t pos, Poco::Int16&) { prepareFixedSize(pos, SQL_C_SSHORT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_SSHORT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_SSHORT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_SSHORT, val.size()); } -inline void Preparation::prepare(std::size_t pos, Poco::UInt16&) +inline void Preparator::prepare(std::size_t pos, Poco::UInt16&) { prepareFixedSize(pos, SQL_C_USHORT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_USHORT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_USHORT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_USHORT, val.size()); } -inline void Preparation::prepare(std::size_t pos, Poco::Int32&) +inline void Preparator::prepare(std::size_t pos, Poco::Int32&) { prepareFixedSize(pos, SQL_C_SLONG); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_SLONG, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_SLONG, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_SLONG, val.size()); } -inline void Preparation::prepare(std::size_t pos, Poco::UInt32&) +inline void Preparator::prepare(std::size_t pos, Poco::UInt32&) { prepareFixedSize(pos, SQL_C_ULONG); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_ULONG, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_ULONG, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_ULONG, val.size()); } -inline void Preparation::prepare(std::size_t pos, Poco::Int64&) +inline void Preparator::prepare(std::size_t pos, Poco::Int64&) { prepareFixedSize(pos, SQL_C_SBIGINT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_SBIGINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_SBIGINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_SBIGINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, Poco::UInt64&) +inline void Preparator::prepare(std::size_t pos, Poco::UInt64&) { prepareFixedSize(pos, SQL_C_UBIGINT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_UBIGINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_UBIGINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_UBIGINT, val.size()); } #ifndef POCO_LONG_IS_64_BIT -inline void Preparation::prepare(std::size_t pos, long&) +inline void Preparator::prepare(std::size_t pos, long&) { prepareFixedSize(pos, SQL_C_SLONG); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_SLONG, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_SLONG, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_SLONG, val.size()); } #endif -inline void Preparation::prepare(std::size_t pos, bool&) +inline void Preparator::prepare(std::size_t pos, bool&) { prepareFixedSize(pos, SQL_C_BIT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareBoolArray(pos, SQL_C_BIT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareBoolArray(pos, SQL_C_BIT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareBoolArray(pos, SQL_C_BIT, val.size()); } -inline void Preparation::prepare(std::size_t pos, float&) +inline void Preparator::prepare(std::size_t pos, float&) { prepareFixedSize(pos, SQL_C_FLOAT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_FLOAT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_FLOAT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_FLOAT, val.size()); } -inline void Preparation::prepare(std::size_t pos, double&) +inline void Preparator::prepare(std::size_t pos, double&) { prepareFixedSize(pos, SQL_C_DOUBLE); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_DOUBLE, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_DOUBLE, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_DOUBLE, val.size()); } -inline void Preparation::prepare(std::size_t pos, char&) +inline void Preparator::prepare(std::size_t pos, char&) { prepareFixedSize(pos, SQL_C_STINYINT); } -inline void Preparation::prepare(std::size_t pos, std::vector& val) +inline void Preparator::prepare(std::size_t pos, std::vector& val) { prepareFixedSize(pos, SQL_C_STINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::deque& val) +inline void Preparator::prepare(std::size_t pos, std::deque& val) { prepareFixedSize(pos, SQL_C_STINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, std::list& val) +inline void Preparator::prepare(std::size_t pos, std::list& val) { prepareFixedSize(pos, SQL_C_STINYINT, val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::string&) +inline void Preparator::prepare(std::size_t pos, const std::string&) { prepareVariableLen(pos, SQL_C_CHAR, maxDataSize(pos), DT_CHAR); } -inline void Preparation::prepare(std::size_t pos, const std::vector& val) +inline void Preparator::prepare(std::size_t pos, const std::vector& val) { - prepareCharArray(pos, SQL_C_CHAR, maxDataSize(pos), val.size()); + prepareCharArray(pos, SQL_C_CHAR, maxDataSize(pos), val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::deque& val) +inline void Preparator::prepare(std::size_t pos, const std::deque& val) { - prepareCharArray(pos, SQL_C_CHAR, maxDataSize(pos), val.size()); + prepareCharArray(pos, SQL_C_CHAR, maxDataSize(pos), val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::list& val) +inline void Preparator::prepare(std::size_t pos, const std::list& val) { - prepareCharArray(pos, SQL_C_CHAR, maxDataSize(pos), val.size()); + prepareCharArray(pos, SQL_C_CHAR, maxDataSize(pos), val.size()); } -inline void Preparation::prepare(std::size_t pos, const Poco::Data::BLOB&) +inline void Preparator::prepare(std::size_t pos, const Poco::Data::BLOB&) { - prepareVariableLen(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR); + prepareVariableLen(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR); } -inline void Preparation::prepare(std::size_t pos, const std::vector& val) +inline void Preparator::prepare(std::size_t pos, const std::vector& val) { - prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); + prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::deque& val) +inline void Preparator::prepare(std::size_t pos, const std::deque& val) { - prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); + prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::list& val) +inline void Preparator::prepare(std::size_t pos, const std::list& val) { - prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); + prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); } -inline void Preparation::prepare(std::size_t pos, const Poco::Data::Date&) +inline void Preparator::prepare(std::size_t pos, const Poco::Data::CLOB&) +{ + prepareVariableLen(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR); +} + + +inline void Preparator::prepare(std::size_t pos, const std::vector& val) +{ + prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); +} + + +inline void Preparator::prepare(std::size_t pos, const std::deque& val) +{ + prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); +} + + +inline void Preparator::prepare(std::size_t pos, const std::list& val) +{ + prepareCharArray(pos, SQL_C_BINARY, maxDataSize(pos), val.size()); +} + + +inline void Preparator::prepare(std::size_t pos, const Poco::Data::Date&) { prepareFixedSize(pos, SQL_C_TYPE_DATE); } -inline void Preparation::prepare(std::size_t pos, const std::vector& val) +inline void Preparator::prepare(std::size_t pos, const std::vector& val) { prepareFixedSize(pos, SQL_C_TYPE_DATE, val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::deque& val) +inline void Preparator::prepare(std::size_t pos, const std::deque& val) { prepareFixedSize(pos, SQL_C_TYPE_DATE, val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::list& val) +inline void Preparator::prepare(std::size_t pos, const std::list& val) { prepareFixedSize(pos, SQL_C_TYPE_DATE, val.size()); } -inline void Preparation::prepare(std::size_t pos, const Poco::Data::Time&) +inline void Preparator::prepare(std::size_t pos, const Poco::Data::Time&) { prepareFixedSize(pos, SQL_C_TYPE_TIME); } -inline void Preparation::prepare(std::size_t pos, const std::vector& val) +inline void Preparator::prepare(std::size_t pos, const std::vector& val) { prepareFixedSize(pos, SQL_C_TYPE_TIME, val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::deque& val) +inline void Preparator::prepare(std::size_t pos, const std::deque& val) { prepareFixedSize(pos, SQL_C_TYPE_TIME, val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::list& val) +inline void Preparator::prepare(std::size_t pos, const std::list& val) { prepareFixedSize(pos, SQL_C_TYPE_TIME, val.size()); } -inline void Preparation::prepare(std::size_t pos, const Poco::DateTime&) +inline void Preparator::prepare(std::size_t pos, const Poco::DateTime&) { prepareFixedSize(pos, SQL_C_TYPE_TIMESTAMP); } -inline void Preparation::prepare(std::size_t pos, const std::vector& val) +inline void Preparator::prepare(std::size_t pos, const std::vector& val) { prepareFixedSize(pos, SQL_C_TYPE_TIMESTAMP, val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::deque& val) +inline void Preparator::prepare(std::size_t pos, const std::deque& val) { prepareFixedSize(pos, SQL_C_TYPE_TIMESTAMP, val.size()); } -inline void Preparation::prepare(std::size_t pos, const std::list& val) +inline void Preparator::prepare(std::size_t pos, const std::list& val) { prepareFixedSize(pos, SQL_C_TYPE_TIMESTAMP, val.size()); } -inline void Preparation::prepare(std::size_t pos, const Poco::Any& val) +inline void Preparator::prepare(std::size_t pos, const Poco::Any& val) { prepareImpl >(pos); } -inline void Preparation::prepare(std::size_t pos, const std::vector& val) +inline void Preparator::prepare(std::size_t pos, const std::vector& val) { prepareImpl >(pos, &val); } -inline void Preparation::prepare(std::size_t pos, const std::deque& val) +inline void Preparator::prepare(std::size_t pos, const std::deque& val) { prepareImpl >(pos, &val); } -inline void Preparation::prepare(std::size_t pos, const std::list& val) +inline void Preparator::prepare(std::size_t pos, const std::list& val) { prepareImpl >(pos, &val); } -inline void Preparation::prepare(std::size_t pos, const Poco::DynamicAny& val) +inline void Preparator::prepare(std::size_t pos, const Poco::DynamicAny& val) { prepareImpl >(pos); } -inline void Preparation::prepare(std::size_t pos, const std::vector& val) +inline void Preparator::prepare(std::size_t pos, const std::vector& val) { prepareImpl >(pos, &val); } -inline void Preparation::prepare(std::size_t pos, const std::deque& val) +inline void Preparator::prepare(std::size_t pos, const std::deque& val) { prepareImpl >(pos, &val); } -inline void Preparation::prepare(std::size_t pos, const std::list& val) +inline void Preparator::prepare(std::size_t pos, const std::list& val) { prepareImpl >(pos, &val); } -inline std::size_t Preparation::bulkSize(std::size_t col) const +inline std::size_t Preparator::bulkSize(std::size_t col) const { poco_assert (col < _lenLengths.size()); @@ -1118,31 +1190,31 @@ inline std::size_t Preparation::bulkSize(std::size_t col) const } -inline void Preparation::setMaxFieldSize(std::size_t size) +inline void Preparator::setMaxFieldSize(std::size_t size) { _maxFieldSize = size; } -inline std::size_t Preparation::getMaxFieldSize() const +inline std::size_t Preparator::getMaxFieldSize() const { return _maxFieldSize; } -inline void Preparation::setDataExtraction(Preparation::DataExtraction ext) +inline void Preparator::setDataExtraction(Preparator::DataExtraction ext) { _dataExtraction = ext; } -inline Preparation::DataExtraction Preparation::getDataExtraction() const +inline Preparator::DataExtraction Preparator::getDataExtraction() const { return _dataExtraction; } -inline Poco::Any& Preparation::operator [] (std::size_t pos) +inline Poco::Any& Preparator::operator [] (std::size_t pos) { return _values.at(pos); } @@ -1151,4 +1223,4 @@ inline Poco::Any& Preparation::operator [] (std::size_t pos) } } } // namespace Poco::Data::ODBC -#endif // Data_ODBC_Preparation_INCLUDED +#endif // Data_ODBC_Preparator_INCLUDED diff --git a/Data/ODBC/src/Binder.cpp b/Data/ODBC/src/Binder.cpp index fb9a1d15e..4ce968e54 100644 --- a/Data/ODBC/src/Binder.cpp +++ b/Data/ODBC/src/Binder.cpp @@ -36,7 +36,7 @@ #include "Poco/Data/ODBC/Binder.h" #include "Poco/Data/ODBC/Utility.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/ODBC/ODBCException.h" #include "Poco/DateTime.h" #include "Poco/Exception.h" @@ -147,40 +147,6 @@ void Binder::bind(std::size_t pos, const std::string& val, Direction dir) } -void Binder::bind(std::size_t pos, const BLOB& val, Direction dir) -{ - if (isOutBound(dir) || !isInBound(dir)) - throw NotImplementedException("BLOB parameter type can only be inbound."); - - SQLPOINTER pVal = (SQLPOINTER) val.rawContent(); - SQLINTEGER size = (SQLINTEGER) val.size(); - - _inParams.insert(ParamMap::value_type(pVal, size)); - - SQLLEN* pLenIn = new SQLLEN; - *pLenIn = size; - - if (PB_AT_EXEC == _paramBinding) - *pLenIn = SQL_LEN_DATA_AT_EXEC(size); - - _lengthIndicator.push_back(pLenIn); - - if (Utility::isError(SQLBindParameter(_rStmt, - (SQLUSMALLINT) pos + 1, - SQL_PARAM_INPUT, - SQL_C_BINARY, - SQL_LONGVARBINARY, - (SQLUINTEGER) size, - 0, - pVal, - (SQLINTEGER) size, - _lengthIndicator.back()))) - { - throw StatementException(_rStmt, "SQLBindParameter(BLOB)"); - } -} - - void Binder::bind(std::size_t pos, const Date& val, Direction dir) { SQLINTEGER size = (SQLINTEGER) sizeof(SQL_DATE_STRUCT); diff --git a/Data/ODBC/src/Extractor.cpp b/Data/ODBC/src/Extractor.cpp index d4434a6fe..490d6d2c2 100644 --- a/Data/ODBC/src/Extractor.cpp +++ b/Data/ODBC/src/Extractor.cpp @@ -38,7 +38,7 @@ #include "Poco/Data/ODBC/ODBCMetaColumn.h" #include "Poco/Data/ODBC/Utility.h" #include "Poco/Data/ODBC/ODBCException.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Buffer.h" #include "Poco/Exception.h" @@ -55,10 +55,10 @@ const std::string Extractor::FLD_SIZE_EXCEEDED_FMT = "Specified data size (%z by Extractor::Extractor(const StatementHandle& rStmt, - Preparation& rPreparation): + Preparator& rPreparator): _rStmt(rStmt), - _rPreparation(rPreparation), - _dataExtraction(rPreparation.getDataExtraction()) + _rPreparator(rPreparator), + _dataExtraction(rPreparator.getDataExtraction()) { } @@ -73,8 +73,8 @@ bool Extractor::extractBoundImpl(std::size_t pos, std::string& val) { if (isNull(pos)) return false; - std::size_t dataSize = _rPreparation.actualDataSize(pos); - char* sp = AnyCast(_rPreparation[pos]); + std::size_t dataSize = _rPreparator.actualDataSize(pos); + char* sp = AnyCast(_rPreparator[pos]); std::size_t len = std::strlen(sp); if (len < dataSize) dataSize = len; checkDataSize(dataSize); @@ -84,127 +84,11 @@ bool Extractor::extractBoundImpl(std::size_t pos, std::string& val) } -template<> -bool Extractor::extractBoundImplContainer >(std::size_t pos, - std::vector& values) -{ - char** pc = AnyCast(&_rPreparation[pos]); - poco_assert_dbg (pc); - poco_assert_dbg (_rPreparation.bulkSize() == values.size()); - std::size_t colWidth = columnSize(pos); - std::vector::iterator it = values.begin(); - std::vector::iterator end = values.end(); - for (int row = 0; it != end; ++it, ++row) - it->assign(*pc + row * colWidth, _rPreparation.actualDataSize(pos, row)); - - return true; -} - - -template<> -bool Extractor::extractBoundImplContainer >(std::size_t pos, - std::deque& values) -{ - char** pc = AnyCast(&_rPreparation[pos]); - poco_assert_dbg (pc); - poco_assert_dbg (_rPreparation.bulkSize() == values.size()); - std::size_t colWidth = columnSize(pos); - std::deque::iterator it = values.begin(); - std::deque::iterator end = values.end(); - for (int row = 0; it != end; ++it, ++row) - it->assign(*pc + row * colWidth, _rPreparation.actualDataSize(pos, row)); - - return true; -} - - -template<> -bool Extractor::extractBoundImplContainer >(std::size_t pos, - std::list& values) -{ - char** pc = AnyCast(&_rPreparation[pos]); - poco_assert_dbg (pc); - poco_assert_dbg (_rPreparation.bulkSize() == values.size()); - std::size_t colWidth = columnSize(pos); - std::list::iterator it = values.begin(); - std::list::iterator end = values.end(); - for (int row = 0; it != end; ++it, ++row) - it->assign(*pc + row * colWidth, _rPreparation.actualDataSize(pos, row)); - - return true; -} - - -template<> -bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data::BLOB& val) -{ - if (isNull(pos)) return false; - - std::size_t dataSize = _rPreparation.actualDataSize(pos); - checkDataSize(dataSize); - char* sp = AnyCast(_rPreparation[pos]); - val.assignRaw(sp, dataSize); - - return true; -} - - -template<> -bool Extractor::extractBoundImplContainer >(std::size_t pos, - std::vector& values) -{ - char** pc = AnyCast(&_rPreparation[pos]); - poco_assert_dbg (pc); - poco_assert_dbg (_rPreparation.bulkSize() == values.size()); - std::size_t colWidth = _rPreparation.maxDataSize(pos); - std::vector::iterator it = values.begin(); - std::vector::iterator end = values.end(); - for (int row = 0; it != end; ++it, ++row) - it->assignRaw(*pc + row * colWidth, _rPreparation.actualDataSize(pos, row)); - - return true; -} - - -template<> -bool Extractor::extractBoundImplContainer >(std::size_t pos, - std::deque& values) -{ - char** pc = AnyCast(&_rPreparation[pos]); - poco_assert_dbg (pc); - poco_assert_dbg (_rPreparation.bulkSize() == values.size()); - std::size_t colWidth = _rPreparation.maxDataSize(pos); - std::deque::iterator it = values.begin(); - std::deque::iterator end = values.end(); - for (int row = 0; it != end; ++it, ++row) - it->assignRaw(*pc + row * colWidth, _rPreparation.actualDataSize(pos, row)); - - return true; -} - - -template<> -bool Extractor::extractBoundImplContainer >(std::size_t pos, - std::list& values) -{ - char** pc = AnyCast(&_rPreparation[pos]); - poco_assert_dbg (pc); - poco_assert_dbg (_rPreparation.bulkSize() == values.size()); - std::size_t colWidth = _rPreparation.maxDataSize(pos); - std::list::iterator it = values.begin(); - std::list::iterator end = values.end(); - for (int row = 0; it != end; ++it, ++row) - it->assignRaw(*pc + row * colWidth, _rPreparation.actualDataSize(pos, row)); - - return true; -} - - template<> bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data::Date& val) { if (isNull(pos)) return false; - SQL_DATE_STRUCT& ds = *AnyCast(&_rPreparation[pos]); + SQL_DATE_STRUCT& ds = *AnyCast(&_rPreparator[pos]); Utility::dateSync(val, ds); return true; } @@ -214,7 +98,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::vector& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::dateSync(val, ds); return true; } @@ -224,7 +108,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::deque& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::dateSync(val, ds); return true; } @@ -234,7 +118,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::list& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::dateSync(val, ds); return true; } @@ -245,9 +129,9 @@ bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data:: { if (isNull(pos)) return false; - std::size_t dataSize = _rPreparation.actualDataSize(pos); + std::size_t dataSize = _rPreparator.actualDataSize(pos); checkDataSize(dataSize); - SQL_TIME_STRUCT& ts = *AnyCast(&_rPreparation[pos]); + SQL_TIME_STRUCT& ts = *AnyCast(&_rPreparator[pos]); Utility::timeSync(val, ts); return true; @@ -258,7 +142,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::vector& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::timeSync(val, ds); return true; } @@ -268,7 +152,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::deque& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::timeSync(val, ds); return true; } @@ -278,7 +162,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::list& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::timeSync(val, ds); return true; } @@ -289,9 +173,9 @@ bool Extractor::extractBoundImpl(std::size_t pos, Poco::DateTime { if (isNull(pos)) return false; - std::size_t dataSize = _rPreparation.actualDataSize(pos); + std::size_t dataSize = _rPreparator.actualDataSize(pos); checkDataSize(dataSize); - SQL_TIMESTAMP_STRUCT& tss = *AnyCast(&_rPreparation[pos]); + SQL_TIMESTAMP_STRUCT& tss = *AnyCast(&_rPreparator[pos]); Utility::dateTimeSync(val, tss); return true; @@ -302,7 +186,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::vector& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::dateTimeSync(val, ds); return true; } @@ -312,7 +196,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::deque& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::dateTimeSync(val, ds); return true; } @@ -322,7 +206,7 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::list& val) { - std::vector& ds = RefAnyCast >(_rPreparation[pos]); + std::vector& ds = RefAnyCast >(_rPreparator[pos]); Utility::dateTimeSync(val, ds); return true; } @@ -332,8 +216,8 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::vector& val) { - std::size_t length = _rPreparation.getLength(); - bool** p = AnyCast(&_rPreparation[pos]); + std::size_t length = _rPreparator.getLength(); + bool** p = AnyCast(&_rPreparator[pos]); val.assign(*p, *p + length); return true; } @@ -343,8 +227,8 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::deque& val) { - std::size_t length = _rPreparation.getLength(); - bool** p = AnyCast(&_rPreparation[pos]); + std::size_t length = _rPreparator.getLength(); + bool** p = AnyCast(&_rPreparator[pos]); val.assign(*p, *p + length); return true; } @@ -354,8 +238,8 @@ template<> bool Extractor::extractBoundImplContainer >(std::size_t pos, std::list& val) { - std::size_t length = _rPreparation.getLength(); - bool** p = AnyCast(&_rPreparation[pos]); + std::size_t length = _rPreparator.getLength(); + bool** p = AnyCast(&_rPreparator[pos]); val.assign(*p, *p + length); return true; } @@ -364,7 +248,7 @@ bool Extractor::extractBoundImplContainer >(std::size_t pos, template<> bool Extractor::extractManualImpl(std::size_t pos, std::string& val, SQLSMALLINT cType) { - std::size_t maxSize = _rPreparation.getMaxFieldSize(); + std::size_t maxSize = _rPreparator.getMaxFieldSize(); std::size_t fetchedSize = 0; std::size_t totalSize = 0; @@ -416,11 +300,11 @@ bool Extractor::extractManualImpl(std::size_t pos, std::string& val template<> -bool Extractor::extractManualImpl(std::size_t pos, - Poco::Data::BLOB& val, +bool Extractor::extractManualImpl(std::size_t pos, + Poco::Data::CLOB& val, SQLSMALLINT cType) { - std::size_t maxSize = _rPreparation.getMaxFieldSize(); + std::size_t maxSize = _rPreparator.getMaxFieldSize(); std::size_t fetchedSize = 0; std::size_t totalSize = 0; @@ -553,7 +437,7 @@ bool Extractor::extractManualImpl(std::size_t pos, bool Extractor::extract(std::size_t pos, Poco::Int32& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_SLONG); else return extractBoundImpl(pos, val); @@ -562,7 +446,7 @@ bool Extractor::extract(std::size_t pos, Poco::Int32& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -571,7 +455,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -580,7 +464,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -589,7 +473,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::Int64& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_SBIGINT); else return extractBoundImpl(pos, val); @@ -598,7 +482,7 @@ bool Extractor::extract(std::size_t pos, Poco::Int64& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -607,7 +491,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -616,7 +500,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -626,7 +510,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) #ifndef POCO_LONG_IS_64_BIT bool Extractor::extract(std::size_t pos, long& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_SLONG); else return extractBoundImpl(pos, val); @@ -635,7 +519,7 @@ bool Extractor::extract(std::size_t pos, long& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -644,7 +528,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -653,7 +537,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -663,7 +547,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, double& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_DOUBLE); else return extractBoundImpl(pos, val); @@ -672,7 +556,7 @@ bool Extractor::extract(std::size_t pos, double& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -681,7 +565,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -690,7 +574,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -699,7 +583,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, std::string& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_CHAR); else return extractBoundImpl(pos, val); @@ -708,7 +592,7 @@ bool Extractor::extract(std::size_t pos, std::string& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -717,7 +601,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -726,7 +610,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -735,7 +619,16 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) + return extractManualImpl(pos, val, SQL_C_BINARY); + else + return extractBoundImpl(pos, val); +} + + +bool Extractor::extract(std::size_t pos, Poco::Data::CLOB& val) +{ + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_BINARY); else return extractBoundImpl(pos, val); @@ -744,7 +637,7 @@ bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -753,7 +646,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -762,7 +655,34 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) + return extractBoundImplContainer(pos, val); + else + throw InvalidAccessException("Direct container extraction only allowed for bound mode."); +} + + +bool Extractor::extract(std::size_t pos, std::vector& val) +{ + if (Preparator::DE_BOUND == _dataExtraction) + return extractBoundImplContainer(pos, val); + else + throw InvalidAccessException("Direct container extraction only allowed for bound mode."); +} + + +bool Extractor::extract(std::size_t pos, std::deque& val) +{ + if (Preparator::DE_BOUND == _dataExtraction) + return extractBoundImplContainer(pos, val); + else + throw InvalidAccessException("Direct container extraction only allowed for bound mode."); +} + + +bool Extractor::extract(std::size_t pos, std::list& val) +{ + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -771,7 +691,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::Data::Date& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_TYPE_DATE); else return extractBoundImpl(pos, val); @@ -780,7 +700,7 @@ bool Extractor::extract(std::size_t pos, Poco::Data::Date& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -789,7 +709,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -798,7 +718,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -807,7 +727,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::Data::Time& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_TYPE_TIME); else return extractBoundImpl(pos, val); @@ -816,7 +736,7 @@ bool Extractor::extract(std::size_t pos, Poco::Data::Time& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -825,7 +745,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -834,7 +754,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -843,7 +763,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::DateTime& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_TYPE_TIMESTAMP); else return extractBoundImpl(pos, val); @@ -852,7 +772,7 @@ bool Extractor::extract(std::size_t pos, Poco::DateTime& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -861,7 +781,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -870,7 +790,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -879,7 +799,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::Int8& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_STINYINT); else return extractBoundImpl(pos, val); @@ -888,7 +808,7 @@ bool Extractor::extract(std::size_t pos, Poco::Int8& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -897,7 +817,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -906,7 +826,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -915,7 +835,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::UInt8& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_UTINYINT); else return extractBoundImpl(pos, val); @@ -924,7 +844,7 @@ bool Extractor::extract(std::size_t pos, Poco::UInt8& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -933,7 +853,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -942,7 +862,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -951,7 +871,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::Int16& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_SSHORT); else return extractBoundImpl(pos, val); @@ -960,7 +880,7 @@ bool Extractor::extract(std::size_t pos, Poco::Int16& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -969,7 +889,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -978,7 +898,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -987,7 +907,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::UInt16& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_USHORT); else return extractBoundImpl(pos, val); @@ -996,7 +916,7 @@ bool Extractor::extract(std::size_t pos, Poco::UInt16& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1005,7 +925,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1014,7 +934,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1023,7 +943,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::UInt32& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_ULONG); else return extractBoundImpl(pos, val); @@ -1032,7 +952,7 @@ bool Extractor::extract(std::size_t pos, Poco::UInt32& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1041,7 +961,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1050,7 +970,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1059,7 +979,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, Poco::UInt64& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_SBIGINT); else return extractBoundImpl(pos, val); @@ -1068,7 +988,7 @@ bool Extractor::extract(std::size_t pos, Poco::UInt64& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1077,7 +997,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1086,7 +1006,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1095,7 +1015,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, bool& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_BIT); else return extractBoundImpl(pos, val); @@ -1104,7 +1024,7 @@ bool Extractor::extract(std::size_t pos, bool& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1113,7 +1033,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1122,7 +1042,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1131,7 +1051,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, float& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_FLOAT); else return extractBoundImpl(pos, val); @@ -1140,7 +1060,7 @@ bool Extractor::extract(std::size_t pos, float& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1149,7 +1069,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1158,7 +1078,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1167,7 +1087,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::extract(std::size_t pos, char& val) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) return extractManualImpl(pos, val, SQL_C_STINYINT); else return extractBoundImpl(pos, val); @@ -1176,7 +1096,7 @@ bool Extractor::extract(std::size_t pos, char& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1185,7 +1105,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1194,7 +1114,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImplContainer(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1209,7 +1129,7 @@ bool Extractor::extract(std::size_t pos, Poco::Any& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImpl(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1218,7 +1138,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImpl(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1227,7 +1147,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImpl(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1242,7 +1162,7 @@ bool Extractor::extract(std::size_t pos, Poco::DynamicAny& val) bool Extractor::extract(std::size_t pos, std::vector& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImpl(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1251,7 +1171,7 @@ bool Extractor::extract(std::size_t pos, std::vector& val) bool Extractor::extract(std::size_t pos, std::deque& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImpl(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1260,7 +1180,7 @@ bool Extractor::extract(std::size_t pos, std::deque& val) bool Extractor::extract(std::size_t pos, std::list& val) { - if (Preparation::DE_BOUND == _dataExtraction) + if (Preparator::DE_BOUND == _dataExtraction) return extractBoundImpl(pos, val); else throw InvalidAccessException("Direct container extraction only allowed for bound mode."); @@ -1269,7 +1189,7 @@ bool Extractor::extract(std::size_t pos, std::list& val) bool Extractor::isNull(std::size_t col, std::size_t row) { - if (Preparation::DE_MANUAL == _dataExtraction) + if (Preparator::DE_MANUAL == _dataExtraction) { try { @@ -1280,13 +1200,13 @@ bool Extractor::isNull(std::size_t col, std::size_t row) } } else - return SQL_NULL_DATA == _rPreparation.actualDataSize(col, row); + return SQL_NULL_DATA == _rPreparator.actualDataSize(col, row); } void Extractor::checkDataSize(std::size_t size) { - std::size_t maxSize = _rPreparation.getMaxFieldSize(); + std::size_t maxSize = _rPreparator.getMaxFieldSize(); if (size > maxSize) throw DataException(format(FLD_SIZE_EXCEEDED_FMT, size, maxSize)); } diff --git a/Data/ODBC/src/ODBCStatementImpl.cpp b/Data/ODBC/src/ODBCStatementImpl.cpp index 7910a3c7a..804b44339 100644 --- a/Data/ODBC/src/ODBCStatementImpl.cpp +++ b/Data/ODBC/src/ODBCStatementImpl.cpp @@ -38,7 +38,7 @@ #include "Poco/Data/ODBC/ConnectionHandle.h" #include "Poco/Data/ODBC/Utility.h" #include "Poco/Data/ODBC/ODBCException.h" -#include "Poco/Data/AbstractPrepare.h" +#include "Poco/Data/AbstractPreparation.h" #include "Poco/Exception.h" @@ -92,9 +92,9 @@ void ODBCStatementImpl::compileImpl() _nextResponse = 0; if (_preparations.size()) - PreparationVec().swap(_preparations); + PreparatorVec().swap(_preparations); - addPreparation(); + addPreparator(); Binder::ParameterBinding bind = session().getFeature("autoBind") ? Binder::PB_IMMEDIATE : Binder::PB_AT_EXEC; @@ -136,7 +136,7 @@ void ODBCStatementImpl::makeInternalExtractors() } -void ODBCStatementImpl::addPreparation() +void ODBCStatementImpl::addPreparator() { if (0 == _preparations.size()) { @@ -144,15 +144,15 @@ void ODBCStatementImpl::addPreparation() if (statement.empty()) throw ODBCException("Empty statements are illegal"); - Preparation::DataExtraction ext = session().getFeature("autoExtract") ? - Preparation::DE_BOUND : Preparation::DE_MANUAL; + Preparator::DataExtraction ext = session().getFeature("autoExtract") ? + Preparator::DE_BOUND : Preparator::DE_MANUAL; std::size_t maxFieldSize = AnyCast(session().getProperty("maxFieldSize")); - _preparations.push_back(new Preparation(_stmt, statement, maxFieldSize, ext)); + _preparations.push_back(new Preparator(_stmt, statement, maxFieldSize, ext)); } else - _preparations.push_back(new Preparation(*_preparations[0])); + _preparations.push_back(new Preparator(*_preparations[0])); _extractors.push_back(new Extractor(_stmt, *_preparations.back())); } @@ -180,7 +180,7 @@ void ODBCStatementImpl::doPrepare() for (std::size_t pos = 0; it != itEnd; ++it) { - AbstractPrepare* pAP = (*it)->createPrepareObject(_preparations[curDataSet], pos); + AbstractPreparation* pAP = (*it)->createPreparation(_preparations[curDataSet], pos); pAP->prepare(); pos += (*it)->numOfColumnsHandled(); delete pAP; @@ -312,7 +312,7 @@ bool ODBCStatementImpl::hasNext() if (SQL_NO_DATA == SQLMoreResults(_stmt)) return false; - addPreparation(); + addPreparator(); doPrepare(); fixupExtraction(); makeStep(); diff --git a/Data/ODBC/src/Preparation.cpp b/Data/ODBC/src/Preparator.cpp similarity index 73% rename from Data/ODBC/src/Preparation.cpp rename to Data/ODBC/src/Preparator.cpp index 7dddb46f0..3338ce560 100644 --- a/Data/ODBC/src/Preparation.cpp +++ b/Data/ODBC/src/Preparator.cpp @@ -1,11 +1,11 @@ // -// Preparation.cpp +// Preparator.cpp // -// $Id: //poco/Main/Data/ODBC/src/Preparation.cpp#5 $ +// $Id: //poco/Main/Data/ODBC/src/Preparator.cpp#5 $ // // Library: Data // Package: DataCore -// Module: Preparation +// Module: Preparator // // Copyright (c) 2006, Applied Informatics Software Engineering GmbH. // and Contributors. @@ -34,7 +34,7 @@ // -#include "Poco/Data/ODBC/Preparation.h" +#include "Poco/Data/ODBC/Preparator.h" #include "Poco/Data/ODBC/ODBCMetaColumn.h" #include "Poco/Exception.h" @@ -47,7 +47,7 @@ namespace Data { namespace ODBC { -Preparation::Preparation(const StatementHandle& rStmt, +Preparator::Preparator(const StatementHandle& rStmt, const std::string& statement, std::size_t maxFieldSize, DataExtraction dataExtraction): @@ -61,7 +61,7 @@ Preparation::Preparation(const StatementHandle& rStmt, } -Preparation::Preparation(const Preparation& other): +Preparator::Preparator(const Preparator& other): _rStmt(other._rStmt), _maxFieldSize(other._maxFieldSize), _dataExtraction(other._dataExtraction) @@ -70,13 +70,13 @@ Preparation::Preparation(const Preparation& other): } -Preparation::~Preparation() +Preparator::~Preparator() { freeMemory(); } -void Preparation::freeMemory() const +void Preparator::freeMemory() const { IndexMap::iterator it = _varLengthArrays.begin(); IndexMap::iterator end = _varLengthArrays.end(); @@ -92,6 +92,10 @@ void Preparation::freeMemory() const deleteCachedArray(it->first); break; + case DT_UCHAR: + deleteCachedArray(it->first); + break; + case DT_CHAR_ARRAY: { char** pc = AnyCast(&_values[it->first]); @@ -99,6 +103,13 @@ void Preparation::freeMemory() const break; } + case DT_UCHAR_ARRAY: + { + unsigned char** pc = AnyCast(&_values[it->first]); + if (pc) std::free(*pc); + break; + } + case DT_BOOL_ARRAY: { bool** pb = AnyCast(&_values[it->first]); @@ -113,14 +124,14 @@ void Preparation::freeMemory() const } -std::size_t Preparation::columns() const +std::size_t Preparator::columns() const { if (_values.empty()) resize(); return _values.size(); } -void Preparation::resize() const +void Preparator::resize() const { SQLSMALLINT nCol = 0; if (!Utility::isError(SQLNumResultCols(_rStmt, &nCol)) && 0 != nCol) @@ -137,7 +148,7 @@ void Preparation::resize() const } -std::size_t Preparation::maxDataSize(std::size_t pos) const +std::size_t Preparator::maxDataSize(std::size_t pos) const { poco_assert_dbg (pos < _values.size()); @@ -160,7 +171,7 @@ std::size_t Preparation::maxDataSize(std::size_t pos) const } -std::size_t Preparation::actualDataSize(std::size_t col, std::size_t row) const +std::size_t Preparator::actualDataSize(std::size_t col, std::size_t row) const { SQLLEN size = (POCO_DATA_INVALID_ROW == row) ? _lengths.at(col) : _lenLengths.at(col).at(row); @@ -172,33 +183,7 @@ std::size_t Preparation::actualDataSize(std::size_t col, std::size_t row) const } -void Preparation::prepareCharArray(std::size_t pos, SQLSMALLINT valueType, std::size_t size, std::size_t length) -{ - poco_assert_dbg (DE_BOUND == _dataExtraction); - poco_assert_dbg (pos < _values.size()); - poco_assert_dbg (pos < _lengths.size()); - poco_assert_dbg (pos < _lenLengths.size()); - - char* pArray = (char*) std::calloc(length * size, sizeof(char)); - - _values[pos] = Any(pArray); - _lengths[pos] = 0; - _lenLengths[pos].resize(length); - _varLengthArrays.insert(IndexMap::value_type(pos, DT_CHAR_ARRAY)); - - if (Utility::isError(SQLBindCol(_rStmt, - (SQLUSMALLINT) pos + 1, - valueType, - (SQLPOINTER) pArray, - (SQLINTEGER) size, - &_lenLengths[pos][0]))) - { - throw StatementException(_rStmt, "SQLBindCol()"); - } -} - - -void Preparation::prepareBoolArray(std::size_t pos, SQLSMALLINT valueType, std::size_t length) +void Preparator::prepareBoolArray(std::size_t pos, SQLSMALLINT valueType, std::size_t length) { poco_assert_dbg (DE_BOUND == _dataExtraction); poco_assert_dbg (pos < _values.size()); diff --git a/Data/ODBC/testsuite/src/ODBCAccessTest.cpp b/Data/ODBC/testsuite/src/ODBCAccessTest.cpp index 7a08fc44f..997b301fd 100644 --- a/Data/ODBC/testsuite/src/ODBCAccessTest.cpp +++ b/Data/ODBC/testsuite/src/ODBCAccessTest.cpp @@ -36,7 +36,7 @@ #include "Poco/String.h" #include "Poco/Format.h" #include "Poco/Exception.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/StatementImpl.h" #include "Poco/Data/ODBC/Connector.h" #include "Poco/Data/ODBC/Utility.h" diff --git a/Data/ODBC/testsuite/src/ODBCDB2Test.cpp b/Data/ODBC/testsuite/src/ODBCDB2Test.cpp index fcbaff325..347f4acdb 100644 --- a/Data/ODBC/testsuite/src/ODBCDB2Test.cpp +++ b/Data/ODBC/testsuite/src/ODBCDB2Test.cpp @@ -39,7 +39,7 @@ #include "Poco/DynamicAny.h" #include "Poco/Tuple.h" #include "Poco/Exception.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/StatementImpl.h" #include "Poco/Data/ODBC/Connector.h" #include "Poco/Data/ODBC/Utility.h" diff --git a/Data/ODBC/testsuite/src/ODBCMySQLTest.cpp b/Data/ODBC/testsuite/src/ODBCMySQLTest.cpp index 27accfbba..2f432d209 100644 --- a/Data/ODBC/testsuite/src/ODBCMySQLTest.cpp +++ b/Data/ODBC/testsuite/src/ODBCMySQLTest.cpp @@ -38,7 +38,7 @@ #include "Poco/Format.h" #include "Poco/Tuple.h" #include "Poco/Exception.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/StatementImpl.h" #include "Poco/Data/ODBC/Connector.h" #include "Poco/Data/ODBC/Utility.h" diff --git a/Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp b/Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp index 78f4e3084..ae27bf5b1 100644 --- a/Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp +++ b/Data/ODBC/testsuite/src/ODBCSQLServerTest.cpp @@ -50,7 +50,7 @@ using namespace Poco::Data::Keywords; using Poco::Data::DataException; using Poco::Data::Statement; using Poco::Data::RecordSet; -using Poco::Data::BLOB; +using Poco::Data::CLOB; using Poco::Data::ODBC::Utility; using Poco::Data::ODBC::ConnectionException; using Poco::Data::ODBC::StatementException; @@ -237,7 +237,7 @@ void ODBCSQLServerTest::testBulk() recreateMiscTable(); _pExecutor->doBulkWithBool, std::vector, - std::vector, + std::vector, std::vector, std::vector, std::vector >(100, "CONVERT(VARBINARY(30),?)"); @@ -245,7 +245,7 @@ void ODBCSQLServerTest::testBulk() recreateMiscTable(); _pExecutor->doBulkWithBool, std::deque, - std::deque, + std::deque, std::deque, std::deque, std::deque >(100, "CONVERT(VARBINARY(30),?)"); @@ -253,7 +253,7 @@ void ODBCSQLServerTest::testBulk() recreateMiscTable(); _pExecutor->doBulkWithBool, std::list, - std::list, + std::list, std::list, std::list, std::list >(100, "CONVERT(VARBINARY(30),?)"); diff --git a/Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp b/Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp index b72e0b84c..692ebd090 100644 --- a/Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp +++ b/Data/ODBC/testsuite/src/ODBCSQLiteTest.cpp @@ -36,7 +36,7 @@ #include "Poco/String.h" #include "Poco/Format.h" #include "Poco/Exception.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/StatementImpl.h" #include "Poco/Data/ODBC/Connector.h" #include "Poco/Data/ODBC/Utility.h" diff --git a/Data/ODBC/testsuite/src/ODBCTest.cpp b/Data/ODBC/testsuite/src/ODBCTest.cpp index 396d1412d..8a8b5f953 100644 --- a/Data/ODBC/testsuite/src/ODBCTest.cpp +++ b/Data/ODBC/testsuite/src/ODBCTest.cpp @@ -40,7 +40,7 @@ #include "Poco/Tuple.h" #include "Poco/DateTime.h" #include "Poco/Exception.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/StatementImpl.h" #include "Poco/Data/ODBC/Connector.h" #include "Poco/Data/ODBC/Utility.h" @@ -53,7 +53,7 @@ using namespace Poco::Data::Keywords; using Poco::Data::Session; -using Poco::Data::BLOB; +using Poco::Data::CLOB; using Poco::Data::ODBC::Utility; using Poco::Data::ODBC::ODBCException; using Poco::Data::ODBC::ConnectionException; @@ -464,21 +464,21 @@ void ODBCTest::testBulk() recreateMiscTable(); _pExecutor->doBulk, std::vector, - std::vector, + std::vector, std::vector, std::vector >(100); recreateMiscTable(); _pExecutor->doBulk, std::deque, - std::deque, + std::deque, std::deque, std::deque >(100); recreateMiscTable(); _pExecutor->doBulk, std::list, - std::list, + std::list, std::list, std::list >(100); } @@ -804,11 +804,11 @@ void ODBCTest::testBLOBContainer() session().setFeature("autoBind", bindValue(i)); session().setFeature("autoExtract", bindValue(i+1)); recreatePersonBLOBTable(); - _pExecutor->blobContainer, std::vector >(10); + _pExecutor->blobContainer, std::vector >(10); recreatePersonBLOBTable(); - _pExecutor->blobContainer, std::deque >(10); + _pExecutor->blobContainer, std::deque >(10); recreatePersonBLOBTable(); - _pExecutor->blobContainer, std::list >(10); + _pExecutor->blobContainer, std::list >(10); i += 2; } } diff --git a/Data/ODBC/testsuite/src/SQLExecutor.cpp b/Data/ODBC/testsuite/src/SQLExecutor.cpp index d48a7cf2f..19c7cf253 100644 --- a/Data/ODBC/testsuite/src/SQLExecutor.cpp +++ b/Data/ODBC/testsuite/src/SQLExecutor.cpp @@ -49,7 +49,7 @@ #include "Poco/Exception.h" #include "Poco/Data/Date.h" #include "Poco/Data/Time.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/StatementImpl.h" #include "Poco/Data/RecordSet.h" #include "Poco/Data/RowIterator.h" @@ -60,7 +60,7 @@ #include "Poco/Data/ODBC/Connector.h" #include "Poco/Data/ODBC/Utility.h" #include "Poco/Data/ODBC/Diagnostics.h" -#include "Poco/Data/ODBC/Preparation.h" +#include "Poco/Data/ODBC/Preparator.h" #include "Poco/Data/ODBC/ODBCException.h" #include "Poco/Data/ODBC/ODBCStatementImpl.h" #include @@ -80,11 +80,11 @@ using Poco::Data::RowIterator; using Poco::Data::SQLChannel; using Poco::Data::LimitException; using Poco::Data::BindingException; -using Poco::Data::BLOB; +using Poco::Data::CLOB; using Poco::Data::Date; using Poco::Data::Time; using Poco::Data::ODBC::Utility; -using Poco::Data::ODBC::Preparation; +using Poco::Data::ODBC::Preparator; using Poco::Data::ODBC::ConnectionException; using Poco::Data::ODBC::StatementException; using Poco::Data::ODBC::DataTruncatedException; @@ -203,7 +203,7 @@ public: pBinder->bind(pos++, obj.age, dir); } - static void prepare(std::size_t pos, Person& obj, AbstractPreparation* pPrepare) + static void prepare(std::size_t pos, Person& obj, AbstractPreparator* pPrepare) { // the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3)) poco_assert_dbg (pPrepare != 0); @@ -254,7 +254,7 @@ public: pBinder->bind(pos++, obj.age, dir); } - static void prepare(std::size_t pos, RefCountedPerson& obj, AbstractPreparation* pPrepare) + static void prepare(std::size_t pos, RefCountedPerson& obj, AbstractPreparator* pPrepare) { // the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3)) poco_assert_dbg (pPrepare != 0); @@ -2348,7 +2348,7 @@ void SQLExecutor::blob(int bigSize, const std::string& blobPlaceholder) std::string firstName("firstname"); std::string address("Address"); - BLOB img("0123456789", 10); + CLOB img("0123456789", 10); int count = 0; try { session() << format("INSERT INTO Person VALUES (?,?,?,%s)", blobPlaceholder), use(lastName), use(firstName), use(address), use(img), now; } @@ -2359,14 +2359,14 @@ void SQLExecutor::blob(int bigSize, const std::string& blobPlaceholder) catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); } assert (count == 1); - BLOB res; + CLOB res; assert (res.size() == 0); try { session() << "SELECT Image FROM Person", into(res), now; } catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); } catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); } assert (res == img); - BLOB big; + CLOB big; std::vector v(bigSize, 'x'); big.assignRaw(&v[0], v.size()); @@ -2394,7 +2394,7 @@ void SQLExecutor::blobStmt() std::string lastName("lastname"); std::string firstName("firstname"); std::string address("Address"); - BLOB blob("0123456789", 10); + CLOB blob("0123456789", 10); int count = 0; Statement ins = (session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(blob)); @@ -2404,7 +2404,7 @@ void SQLExecutor::blobStmt() catch(StatementException& se){ std::cout << se.toString() << std::endl; fail (funct); } assert (count == 1); - BLOB res; + CLOB res; poco_assert (res.size() == 0); Statement stmt = (session() << "SELECT Image FROM Person", into(res)); try { stmt.execute(); } diff --git a/Data/ODBC/testsuite/src/SQLExecutor.h b/Data/ODBC/testsuite/src/SQLExecutor.h index d8976441d..3e3f20e2a 100644 --- a/Data/ODBC/testsuite/src/SQLExecutor.h +++ b/Data/ODBC/testsuite/src/SQLExecutor.h @@ -89,7 +89,7 @@ using Poco::Data::Keywords::use; \ using Poco::Data::Keywords::bulk; \ using Poco::Data::Keywords::limit; \ - using Poco::Data::BLOB; \ + using Poco::Data::CLOB; \ using Poco::Data::ODBC::ConnectionException; \ using Poco::Data::ODBC::StatementException @@ -241,8 +241,8 @@ public: assert (size - 1 == ints.back()); assert (std::string("xyz0") == strings.front()); assert (std::string("xyz") + number == strings.back()); - assert (BLOB("abc0") == blobs.front()); - BLOB blob("abc"); + assert (CLOB("abc0") == blobs.front()); + CLOB blob("abc"); blob.appendRaw(number.c_str(), number.size()); assert (blob == blobs.back()); assert (.5 == floats.front()); @@ -294,7 +294,7 @@ public: assert (size - 1 == ints.back()); assert (std::string("xyz0") == strings.front()); assert (std::string("xyz") + number == strings.back()); - assert (BLOB("abc0") == blobs.front()); + assert (CLOB("abc0") == blobs.front()); blob.assignRaw("abc", 3); blob.appendRaw(number.c_str(), number.size()); assert (blob == blobs.back()); @@ -376,8 +376,8 @@ public: assert (size - 1 == ints.back()); assert (std::string("xyz0") == strings.front()); assert (std::string("xyz") + number == strings.back()); - assert (BLOB("abc0") == blobs.front()); - BLOB blob("abc"); + assert (CLOB("abc0") == blobs.front()); + CLOB blob("abc"); blob.appendRaw(number.c_str(), number.size()); assert (blob == blobs.back()); assert (.5 == floats.front()); @@ -422,7 +422,7 @@ public: assert (size - 1 == ints.back()); assert (std::string("xyz0") == strings.front()); assert (std::string("xyz") + number == strings.back()); - assert (BLOB("abc0") == blobs.front()); + assert (CLOB("abc0") == blobs.front()); blob.assignRaw("abc", 3); blob.appendRaw(number.c_str(), number.size()); assert (blob == blobs.back()); @@ -461,7 +461,7 @@ public: C1 lastName(size, "lastname"); C1 firstName(size, "firstname"); C1 address(size, "Address"); - C2 img(size, BLOB("0123456789", 10)); + C2 img(size, CLOB("0123456789", 10)); int count = 0; try { session() << "INSERT INTO PERSON VALUES (?,?,?,?)", use(lastName), use(firstName), use(address), use(img), now; } catch(ConnectionException& ce){ std::cout << ce.toString() << std::endl; fail (funct); } diff --git a/Data/SQLite/include/Poco/Data/SQLite/Binder.h b/Data/SQLite/include/Poco/Data/SQLite/Binder.h index 9695fcf89..286027d8d 100644 --- a/Data/SQLite/include/Poco/Data/SQLite/Binder.h +++ b/Data/SQLite/include/Poco/Data/SQLite/Binder.h @@ -42,11 +42,10 @@ #include "Poco/Data/SQLite/SQLite.h" #include "Poco/Data/AbstractBinder.h" +#include "Poco/Data/LOB.h" #include "Poco/Any.h" #include "Poco/DynamicAny.h" - - -struct sqlite3_stmt; +#include "sqlite3.h" namespace Poco { @@ -114,6 +113,9 @@ public: void bind(std::size_t pos, const Poco::Data::BLOB& val, Direction dir); /// Binds a BLOB. + void bind(std::size_t pos, const Poco::Data::CLOB& val, Direction dir); + /// Binds a CLOB. + void bind(std::size_t pos, const Date& val, Direction dir); /// Binds a Date. @@ -131,6 +133,17 @@ private: /// Checks the SQLite return code and throws an appropriate exception /// if error has occurred. + template + void bindLOB(std::size_t pos, const Poco::Data::LOB& val, Direction dir) + { + // convert a blob to a an unsigned char* array + const T* pData = reinterpret_cast(val.rawContent()); + int valSize = static_cast(val.size()); + + int rc = sqlite3_bind_blob(_pStmt, static_cast(pos), pData, valSize, SQLITE_STATIC); // no deep copy, do not free memory + checkReturn(rc); + } + sqlite3_stmt* _pStmt; }; @@ -208,6 +221,18 @@ inline void Binder::bind(std::size_t pos, const char* const &pVal, Direction dir } +inline void Binder::bind(std::size_t pos, const Poco::Data::BLOB& val, Direction dir) +{ + bindLOB(pos, val, dir); +} + + +inline void Binder::bind(std::size_t pos, const Poco::Data::CLOB& val, Direction dir) +{ + bindLOB(pos, val, dir); +} + + } } } // namespace Poco::Data::SQLite diff --git a/Data/SQLite/include/Poco/Data/SQLite/Extractor.h b/Data/SQLite/include/Poco/Data/SQLite/Extractor.h index 67ddd5305..2b7bab708 100644 --- a/Data/SQLite/include/Poco/Data/SQLite/Extractor.h +++ b/Data/SQLite/include/Poco/Data/SQLite/Extractor.h @@ -48,13 +48,11 @@ #include "Poco/Data/Constants.h" #include "Poco/Any.h" #include "Poco/DynamicAny.h" +#include "sqlite3.h" #include #include -struct sqlite3_stmt; - - namespace Poco { namespace Data { namespace SQLite { @@ -121,6 +119,9 @@ public: bool extract(std::size_t pos, Poco::Data::BLOB& val); /// Extracts a BLOB. + bool extract(std::size_t pos, Poco::Data::CLOB& val); + /// Extracts a CLOB. + bool extract(std::size_t pos, Poco::Data::Date& val); /// Extracts a Date. @@ -285,6 +286,16 @@ private: return ret; } + template + bool extractLOB(std::size_t pos, Poco::Data::LOB& val) + { + if (isNull(pos)) return false; + int size = sqlite3_column_bytes(_pStmt, (int) pos); + const T* pTmp = reinterpret_cast(sqlite3_column_blob(_pStmt, (int) pos)); + val = Poco::Data::LOB(pTmp, size); + return true; + } + sqlite3_stmt* _pStmt; NullIndVec _nulls; }; @@ -299,6 +310,18 @@ inline void Extractor::reset() } +inline bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val) +{ + return extractLOB(pos, val); +} + + +inline bool Extractor::extract(std::size_t pos, Poco::Data::CLOB& val) +{ + return extractLOB(pos, val); +} + + } } } // namespace Poco::Data::SQLite diff --git a/Data/SQLite/src/Binder.cpp b/Data/SQLite/src/Binder.cpp index 47ae9177f..fc86ff76d 100644 --- a/Data/SQLite/src/Binder.cpp +++ b/Data/SQLite/src/Binder.cpp @@ -38,11 +38,9 @@ #include "Poco/Data/SQLite/Utility.h" #include "Poco/Data/Date.h" #include "Poco/Data/Time.h" -#include "Poco/Data/BLOB.h" #include "Poco/Exception.h" #include "Poco/DateTimeFormatter.h" #include "Poco/DateTimeFormat.h" -#include "sqlite3.h" #include @@ -104,17 +102,6 @@ void Binder::bind(std::size_t pos, const std::string& val, Direction dir) } -void Binder::bind(std::size_t pos, const Poco::Data::BLOB& val, Direction dir) -{ - // convert a blob to a an unsigned char* array - const unsigned char* pData = reinterpret_cast(val.rawContent()); - int valSize = static_cast(val.size()); - - int rc = sqlite3_bind_blob(_pStmt, static_cast(pos), pData, valSize, SQLITE_STATIC); // no deep copy, do not free memory - checkReturn(rc); -} - - void Binder::bind(std::size_t pos, const Date& val, Direction dir) { DateTime dt(val.year(), val.month(), val.day()); diff --git a/Data/SQLite/src/Extractor.cpp b/Data/SQLite/src/Extractor.cpp index 86041e700..e6c7d61ef 100644 --- a/Data/SQLite/src/Extractor.cpp +++ b/Data/SQLite/src/Extractor.cpp @@ -38,11 +38,10 @@ #include "Poco/Data/SQLite/Utility.h" #include "Poco/Data/Date.h" #include "Poco/Data/Time.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/DataException.h" #include "Poco/DateTimeParser.h" #include "Poco/Exception.h" -#include "sqlite3.h" #include @@ -116,17 +115,6 @@ bool Extractor::extract(std::size_t pos, std::string& val) } -bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val) -{ - if (isNull(pos)) - return false; - int size = sqlite3_column_bytes(_pStmt, (int) pos); - const char* pTmp = reinterpret_cast(sqlite3_column_blob(_pStmt, (int) pos)); - val = Poco::Data::BLOB(pTmp, size); - return true; -} - - bool Extractor::extract(std::size_t pos, Poco::Int8& val) { if (isNull(pos)) diff --git a/Data/SQLite/testsuite/src/SQLiteTest.cpp b/Data/SQLite/testsuite/src/SQLiteTest.cpp index 53dbce5fa..104c8abb8 100644 --- a/Data/SQLite/testsuite/src/SQLiteTest.cpp +++ b/Data/SQLite/testsuite/src/SQLiteTest.cpp @@ -35,7 +35,7 @@ #include "CppUnit/TestSuite.h" #include "Poco/Data/Date.h" #include "Poco/Data/Time.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Data/Statement.h" #include "Poco/Data/RecordSet.h" #include "Poco/Data/SQLChannel.h" @@ -65,7 +65,7 @@ using Poco::Data::Column; using Poco::Data::Row; using Poco::Data::SQLChannel; using Poco::Data::LimitException; -using Poco::Data::BLOB; +using Poco::Data::CLOB; using Poco::Data::Date; using Poco::Data::Time; using Poco::Data::AbstractExtractionVec; @@ -143,7 +143,7 @@ public: pBinder->bind(pos++, obj.age, dir); } - static void prepare(std::size_t pos, Person& obj, AbstractPreparation* pPrepare) + static void prepare(std::size_t pos, Person& obj, AbstractPreparator* pPrepare) { // the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Age INTEGER(3)) poco_assert_dbg (pPrepare != 0); @@ -1215,7 +1215,7 @@ void SQLiteTest::testEmptyDB() } -void SQLiteTest::testBLOB() +void SQLiteTest::testCLOB() { std::string lastName("lastname"); std::string firstName("firstname"); @@ -1223,12 +1223,12 @@ void SQLiteTest::testBLOB() Session tmp (Poco::Data::SQLite::Connector::KEY, "dummy.db"); tmp << "DROP TABLE IF EXISTS Person", now; tmp << "CREATE TABLE IF NOT EXISTS Person (LastName VARCHAR(30), FirstName VARCHAR, Address VARCHAR, Image BLOB)", now; - BLOB img("0123456789", 10); + CLOB img("0123456789", 10); int count = 0; tmp << "INSERT INTO PERSON VALUES(:ln, :fn, :ad, :img)", use(lastName), use(firstName), use(address), use(img), now; tmp << "SELECT COUNT(*) FROM PERSON", into(count), now; assert (count == 1); - BLOB res; + CLOB res; poco_assert (res.size() == 0); tmp << "SELECT Image FROM Person WHERE LastName == :ln", bind("lastname"), into(res), now; @@ -2369,7 +2369,7 @@ CppUnit::Test* SQLiteTest::suite() CppUnit_addTest(pSuite, SQLiteTest, testIllegalRange); CppUnit_addTest(pSuite, SQLiteTest, testSingleSelect); CppUnit_addTest(pSuite, SQLiteTest, testEmptyDB); - CppUnit_addTest(pSuite, SQLiteTest, testBLOB); + CppUnit_addTest(pSuite, SQLiteTest, testCLOB); CppUnit_addTest(pSuite, SQLiteTest, testTuple10); CppUnit_addTest(pSuite, SQLiteTest, testTupleVector10); CppUnit_addTest(pSuite, SQLiteTest, testTuple9); diff --git a/Data/SQLite/testsuite/src/SQLiteTest.h b/Data/SQLite/testsuite/src/SQLiteTest.h index 961ffc546..dce456a44 100644 --- a/Data/SQLite/testsuite/src/SQLiteTest.h +++ b/Data/SQLite/testsuite/src/SQLiteTest.h @@ -87,7 +87,7 @@ public: void testSingleSelect(); void testEmptyDB(); - void testBLOB(); + void testCLOB(); void testTuple1(); void testTupleVector1(); diff --git a/Data/include/Poco/Data/AbstractBinder.h b/Data/include/Poco/Data/AbstractBinder.h index ee3abdcc4..5081ad424 100644 --- a/Data/include/Poco/Data/AbstractBinder.h +++ b/Data/include/Poco/Data/AbstractBinder.h @@ -43,7 +43,7 @@ #include "Poco/Data/Data.h" #include "Poco/Data/Date.h" #include "Poco/Data/Time.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/DateTime.h" #include "Poco/Any.h" #include "Poco/Dynamic/Var.h" @@ -266,6 +266,9 @@ public: virtual void bind(std::size_t pos, const BLOB& val, Direction dir = PD_IN) = 0; /// Binds a BLOB. + virtual void bind(std::size_t pos, const CLOB& val, Direction dir = PD_IN) = 0; + /// Binds a CLOB. + virtual void bind(std::size_t pos, const std::vector& val, Direction dir = PD_IN); /// Binds a BLOB vector. @@ -275,6 +278,15 @@ public: virtual void bind(std::size_t pos, const std::list& val, Direction dir = PD_IN); /// Binds a BLOB list. + virtual void bind(std::size_t pos, const std::vector& val, Direction dir = PD_IN); + /// Binds a CLOB vector. + + virtual void bind(std::size_t pos, const std::deque& val, Direction dir = PD_IN); + /// Binds a CLOB deque. + + virtual void bind(std::size_t pos, const std::list& val, Direction dir = PD_IN); + /// Binds a CLOB list. + virtual void bind(std::size_t pos, const DateTime& val, Direction dir = PD_IN) = 0; /// Binds a DateTime. diff --git a/Data/include/Poco/Data/AbstractExtraction.h b/Data/include/Poco/Data/AbstractExtraction.h index 47e7b9e43..846933294 100644 --- a/Data/include/Poco/Data/AbstractExtraction.h +++ b/Data/include/Poco/Data/AbstractExtraction.h @@ -55,8 +55,8 @@ namespace Poco { namespace Data { -class AbstractPrepare; class AbstractPreparation; +class AbstractPreparator; class Data_API AbstractExtraction: public Poco::RefCountedObject @@ -109,8 +109,8 @@ public: virtual bool canExtract() const; /// Returns true. Implementations should override it for different behavior. - virtual AbstractPrepare* createPrepareObject(AbstractPreparation* pPrep, std::size_t pos) = 0; - /// Creates a Prepare object for the extracting object + virtual AbstractPreparation* createPreparation(AbstractPreparator* pPrep, std::size_t pos) = 0; + /// Creates a Preparation object for the extracting object void setLimit(Poco::UInt32 limit); /// Sets the limit. diff --git a/Data/include/Poco/Data/AbstractExtractor.h b/Data/include/Poco/Data/AbstractExtractor.h index 68812e88b..e68a8bc0a 100644 --- a/Data/include/Poco/Data/AbstractExtractor.h +++ b/Data/include/Poco/Data/AbstractExtractor.h @@ -42,6 +42,7 @@ #include "Poco/Data/Data.h" #include "Poco/Data/Constants.h" +#include "Poco/Data/LOB.h" #include #include #include @@ -64,7 +65,6 @@ namespace Data { class Date; class Time; -class BLOB; class Data_API AbstractExtractor @@ -251,6 +251,9 @@ public: virtual bool extract(std::size_t pos, BLOB& val) = 0; /// Extracts a BLOB. Returns false if null was received. + virtual bool extract(std::size_t pos, CLOB& val) = 0; + /// Extracts a CLOB. Returns false if null was received. + virtual bool extract(std::size_t pos, std::vector& val); /// Extracts a BLOB vector. @@ -260,6 +263,15 @@ public: virtual bool extract(std::size_t pos, std::list& val); /// Extracts a BLOB list. + virtual bool extract(std::size_t pos, std::vector& val); + /// Extracts a CLOB vector. + + virtual bool extract(std::size_t pos, std::deque& val); + /// Extracts a CLOB deque. + + virtual bool extract(std::size_t pos, std::list& val); + /// Extracts a CLOB list. + virtual bool extract(std::size_t pos, DateTime& val) = 0; /// Extracts a DateTime. Returns false if null was received. diff --git a/Data/include/Poco/Data/AbstractPreparation.h b/Data/include/Poco/Data/AbstractPreparation.h index af8176e97..faf3ddbce 100644 --- a/Data/include/Poco/Data/AbstractPreparation.h +++ b/Data/include/Poco/Data/AbstractPreparation.h @@ -1,7 +1,7 @@ // // AbstractPreparation.h // -// $Id: //poco/Main/Data/include/Poco/Data/AbstractPreparation.h#5 $ +// $Id: //poco/Main/Data/include/Poco/Data/AbstractPreparation.h#4 $ // // Library: Data // Package: DataCore @@ -41,335 +41,43 @@ #include "Poco/Data/Data.h" -#include "Poco/RefCountedObject.h" -#include -#include -#include #include namespace Poco { - - -class DateTime; -class Any; - -namespace Dynamic { -class Var; -} - - namespace Data { -class Date; -class Time; -class BLOB; +class AbstractPreparator; -class Data_API AbstractPreparation: public Poco::RefCountedObject - /// Interface used for database preparation where we first have to register all data types (and memory output locations) - /// before extracting data, i.e. extract works as two-pase extract: first we call prepare once, then extract n-times. - /// There are cases (bulk operations using std::vector storage) when extract is called only once. - /// The value passed to a prepare() call is not be used by the prepare, serving only as an indication of the data type - /// being prepared. - /// Implementing this interface is not mandatory for a connector. Connectors that only extract data after SQL execution - /// (e.g. SQLite) do not need this functionality at all. +class Data_API AbstractPreparation + /// Interface for calling the appropriate AbstractPreparator method { public: - AbstractPreparation(Poco::UInt32 length = 1u); + AbstractPreparation(AbstractPreparator* pPreparator); /// Creates the AbstractPreparation. virtual ~AbstractPreparation(); /// Destroys the AbstractPreparation. - virtual void prepare(std::size_t pos, Poco::Int8&) = 0; - /// Prepares an Int8. + virtual void prepare() = 0; + /// Preparations data. - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares an Int8 vector. +protected: + AbstractPreparator* preparation(); + /// Returns the preparation object - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares an Int8 deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares an Int8 list. - - virtual void prepare(std::size_t pos, Poco::UInt8&) = 0; - /// Prepares an UInt8. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares an UInt8 vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares an UInt8 deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares an UInt8 list. - - virtual void prepare(std::size_t pos, Poco::Int16&) = 0; - /// Prepares an Int16. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares an Int16 vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares an Int16 deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares an Int16 list. - - virtual void prepare(std::size_t pos, Poco::UInt16&) = 0; - /// Prepares an UInt16. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares an UInt16 vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares an UInt16 deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares an UInt16 list. - - virtual void prepare(std::size_t pos, Poco::Int32&) = 0; - /// Prepares an Int32. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares an Int32 vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares an Int32 deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares an Int32 list. - - virtual void prepare(std::size_t pos, Poco::UInt32&) = 0; - /// Prepares an UInt32. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares an UInt32 vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares an UInt32 deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares an UInt32 list. - - virtual void prepare(std::size_t pos, Poco::Int64&) = 0; - /// Prepares an Int64. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares an Int64 vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares an Int64 deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares an Int64 list. - - virtual void prepare(std::size_t pos, Poco::UInt64&) = 0; - /// Prepares an UInt64. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares an UInt64 vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares an UInt64 deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares an UInt64 list. - -#ifndef POCO_LONG_IS_64_BIT - virtual void prepare(std::size_t pos, long&) = 0; - /// Prepares a long. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares a long vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares a long deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares a long list. -#endif - - virtual void prepare(std::size_t pos, bool&) = 0; - /// Prepares a boolean. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares a boolean vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares a boolean deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares a boolean list. - - virtual void prepare(std::size_t pos, float&) = 0; - /// Prepares a float. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares a float vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares a float deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares a float list. - - virtual void prepare(std::size_t pos, double&) = 0; - /// Prepares a double. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares a double vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares a double deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares a double list. - - virtual void prepare(std::size_t pos, char&) = 0; - /// Prepares a single character. - - virtual void prepare(std::size_t pos, std::vector& val); - /// Prepares a character vector. - - virtual void prepare(std::size_t pos, std::deque& val); - /// Prepares a character deque. - - virtual void prepare(std::size_t pos, std::list& val); - /// Prepares a character list. - - virtual void prepare(std::size_t pos, const std::string&) = 0; - /// Prepares a string. - - virtual void prepare(std::size_t pos, const std::vector& val); - /// Prepares a string vector. - - virtual void prepare(std::size_t pos, const std::deque& val); - /// Prepares a string deque. - - virtual void prepare(std::size_t pos, const std::list& val); - /// Prepares a string list. - - virtual void prepare(std::size_t pos, const BLOB&) = 0; - /// Prepares a BLOB. - - virtual void prepare(std::size_t pos, const std::vector& val); - /// Prepares a BLOB vector. - - virtual void prepare(std::size_t pos, const std::deque& val); - /// Prepares a BLOB deque. - - virtual void prepare(std::size_t pos, const std::list& val); - /// Prepares a BLOB list. - - virtual void prepare(std::size_t pos, const DateTime&) = 0; - /// Prepares a DateTime. - - virtual void prepare(std::size_t pos, const std::vector& val); - /// Prepares a DateTime vector. - - virtual void prepare(std::size_t pos, const std::deque& val); - /// Prepares a DateTime deque. - - virtual void prepare(std::size_t pos, const std::list& val); - /// Prepares a DateTime list. - - virtual void prepare(std::size_t pos, const Date&) = 0; - /// Prepares a Date. - - virtual void prepare(std::size_t pos, const std::vector& val); - /// Prepares a Date vector. - - virtual void prepare(std::size_t pos, const std::deque& val); - /// Prepares a Date deque. - - virtual void prepare(std::size_t pos, const std::list& val); - /// Prepares a Date list. - - virtual void prepare(std::size_t pos, const Time&) = 0; - /// Prepares a Time. - - virtual void prepare(std::size_t pos, const std::vector - - + RelativePath=".\src\Preparator.h"> @@ -334,6 +331,9 @@ + + diff --git a/Data/testsuite/TestSuite_VS80.vcproj b/Data/testsuite/TestSuite_VS80.vcproj index 9082ea5f8..c26fc03a1 100644 --- a/Data/testsuite/TestSuite_VS80.vcproj +++ b/Data/testsuite/TestSuite_VS80.vcproj @@ -440,7 +440,7 @@ > vec; + vec.push_back(0); + vec.push_back(1); + vec.push_back(2); + vec.push_back(3); + vec.push_back(4); + vec.push_back(5); + vec.push_back(6); + vec.push_back(7); + vec.push_back(8); + vec.push_back(9); + + Poco::Data::LOB lobNum1(&vec[0], vec.size()); + assert (lobNum1.size() == vec.size()); + assert (0 == std::memcmp(&vec[0], lobNum1.rawContent(), lobNum1.size() * sizeof(int))); + assert (*lobNum1.begin() == 0); + Poco::Data::LOB::Iterator it1 = lobNum1.end(); + assert (*(--it1) == 9); + + Poco::Data::LOB lobNum2(lobNum1); + assert (lobNum2.size() == lobNum1.size()); + assert (lobNum2 == lobNum1); + lobNum1.swap(lobNum2); + assert (lobNum2 == lobNum1); +} + + +void DataTest::testCLOB() { std::string strDigit = "1234567890"; std::string strAlpha = "abcdefghijklmnopqrstuvwxyz"; std::vector vecAlpha(strAlpha.begin(), strAlpha.end()); std::vector vecDigit(strDigit.begin(), strDigit.end()); - BLOB blobNumStr(strDigit.c_str(), strDigit.size()); + CLOB blobNumStr(strDigit.c_str(), strDigit.size()); assert (blobNumStr.size() == strDigit.size()); assert (0 == std::strncmp(strDigit.c_str(), blobNumStr.rawContent(), blobNumStr.size())); assert (*blobNumStr.begin() == '1'); - assert (*(blobNumStr.end()-1) == '0'); - BLOB blobNumVec(vecDigit); + CLOB::Iterator itNumStr = blobNumStr.end(); + assert (*(--itNumStr) == '0'); + CLOB blobNumVec(vecDigit); assert (blobNumVec.size() == vecDigit.size()); assert (blobNumVec == blobNumStr); blobNumVec.swap(blobNumStr); assert (blobNumVec.size() == blobNumStr.size()); assert (blobNumVec == blobNumStr); - BLOB blobChrStr(strAlpha.c_str(), strAlpha.size()); - BLOB blobChrVec(vecAlpha); + CLOB blobChrStr(strAlpha.c_str(), strAlpha.size()); + CLOB blobChrVec(vecAlpha); assert (blobChrStr.size() == strAlpha.size()); assert (0 == std::strncmp(strAlpha.c_str(), blobChrStr.rawContent(), blobChrStr.size())); assert (*blobChrStr.begin() == 'a'); - assert (*(blobChrStr.end()-1) == 'z'); + CLOB::Iterator itChrStr = blobChrStr.end(); + assert (*(--itChrStr) == 'z'); assert (blobChrStr == blobChrVec); blobNumStr.swap(blobChrStr); @@ -245,26 +276,26 @@ void DataTest::testBLOB() } -void DataTest::testBLOBStreams() +void DataTest::testCLOBStreams() { - BLOB blob; + CLOB blob; assert (0 == blob.size()); - BLOBOutputStream bos(blob); + CLOBOutputStream bos(blob); BinaryWriter bw(bos); assert (0 == blob.size()); - writeToBLOB(bw); + writeToCLOB(bw); assert (blob.size() > 0); - BLOBInputStream bis(blob); + CLOBInputStream bis(blob); BinaryReader br(bis); - readFromBLOB(br); + readFromCLOB(br); } -void DataTest::writeToBLOB(BinaryWriter& writer) +void DataTest::writeToCLOB(BinaryWriter& writer) { writer << true; writer << false; @@ -305,7 +336,7 @@ void DataTest::writeToBLOB(BinaryWriter& writer) } -void DataTest::readFromBLOB(BinaryReader& reader) +void DataTest::readFromCLOB(BinaryReader& reader) { bool b = false; reader >> b; @@ -1294,8 +1325,9 @@ CppUnit::Test* DataTest::suite() CppUnit_addTest(pSuite, DataTest, testStatementFormatting); CppUnit_addTest(pSuite, DataTest, testFeatures); CppUnit_addTest(pSuite, DataTest, testProperties); - CppUnit_addTest(pSuite, DataTest, testBLOB); - CppUnit_addTest(pSuite, DataTest, testBLOBStreams); + CppUnit_addTest(pSuite, DataTest, testLOB); + CppUnit_addTest(pSuite, DataTest, testCLOB); + CppUnit_addTest(pSuite, DataTest, testCLOBStreams); CppUnit_addTest(pSuite, DataTest, testColumnVector); CppUnit_addTest(pSuite, DataTest, testColumnVectorBool); CppUnit_addTest(pSuite, DataTest, testColumnDeque); diff --git a/Data/testsuite/src/DataTest.h b/Data/testsuite/src/DataTest.h index 521d7f0c7..3c78d79dc 100644 --- a/Data/testsuite/src/DataTest.h +++ b/Data/testsuite/src/DataTest.h @@ -53,8 +53,9 @@ public: void testStatementFormatting(); void testFeatures(); void testProperties(); - void testBLOB(); - void testBLOBStreams(); + void testLOB(); + void testCLOB(); + void testCLOBStreams(); void testColumnVector(); void testColumnVectorBool(); void testColumnDeque(); @@ -80,8 +81,8 @@ private: /// For this to pass, the following condition must be satisifed: /// row1 < row2 < row3 - void writeToBLOB(Poco::BinaryWriter& writer); - void readFromBLOB(Poco::BinaryReader& reader); + void writeToCLOB(Poco::BinaryWriter& writer); + void readFromCLOB(Poco::BinaryReader& reader); }; diff --git a/Data/testsuite/src/Extractor.cpp b/Data/testsuite/src/Extractor.cpp index ca60bf1c4..17512ae3f 100644 --- a/Data/testsuite/src/Extractor.cpp +++ b/Data/testsuite/src/Extractor.cpp @@ -31,7 +31,7 @@ #include "Extractor.h" -#include "Poco/Data/BLOB.h" +#include "Poco/Data/LOB.h" #include "Poco/Exception.h" @@ -155,6 +155,12 @@ bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val) return true; } + +bool Extractor::extract(std::size_t pos, Poco::Data::CLOB& val) +{ + return true; +} + bool Extractor::extract(std::size_t pos, Poco::Data::Date& val) { return true; diff --git a/Data/testsuite/src/Extractor.h b/Data/testsuite/src/Extractor.h index 60abcfd7f..c41eab5dd 100644 --- a/Data/testsuite/src/Extractor.h +++ b/Data/testsuite/src/Extractor.h @@ -107,6 +107,9 @@ public: bool extract(std::size_t pos, Poco::Data::BLOB& val); /// Extracts a BLOB. + bool extract(std::size_t pos, Poco::Data::CLOB& val); + /// Extracts a CLOB. + bool extract(std::size_t pos, Date& val); /// Extracts a Date. diff --git a/Data/testsuite/src/Preparation.cpp b/Data/testsuite/src/Preparator.cpp similarity index 52% rename from Data/testsuite/src/Preparation.cpp rename to Data/testsuite/src/Preparator.cpp index 0e436c233..33ef6b16f 100644 --- a/Data/testsuite/src/Preparation.cpp +++ b/Data/testsuite/src/Preparator.cpp @@ -1,7 +1,7 @@ // -// Preparation.cpp +// Preparator.cpp // -// $Id: //poco/Main/Data/testsuite/src/Preparation.cpp#3 $ +// $Id: //poco/Main/Data/testsuite/src/Preparator.cpp#3 $ // // Copyright (c) 2006, Applied Informatics Software Engineering GmbH. // and Contributors. @@ -30,8 +30,8 @@ // -#include "Preparation.h" -#include "Poco/Data/BLOB.h" +#include "Preparator.h" +#include "Poco/Data/LOB.h" #include "Poco/Exception.h" @@ -40,114 +40,119 @@ namespace Data { namespace Test { -Preparation::Preparation() +Preparator::Preparator() { } -Preparation::~Preparation() +Preparator::~Preparator() { } -void Preparation::prepare(std::size_t pos, Poco::Int8&) +void Preparator::prepare(std::size_t pos, Poco::Int8&) { } -void Preparation::prepare(std::size_t pos, Poco::UInt8&) +void Preparator::prepare(std::size_t pos, Poco::UInt8&) { } -void Preparation::prepare(std::size_t pos, Poco::Int16&) +void Preparator::prepare(std::size_t pos, Poco::Int16&) { } -void Preparation::prepare(std::size_t pos, Poco::UInt16&) +void Preparator::prepare(std::size_t pos, Poco::UInt16&) { } -void Preparation::prepare(std::size_t pos, Poco::Int32&) +void Preparator::prepare(std::size_t pos, Poco::Int32&) { } -void Preparation::prepare(std::size_t pos, Poco::UInt32&) +void Preparator::prepare(std::size_t pos, Poco::UInt32&) { } -void Preparation::prepare(std::size_t pos, Poco::Int64&) +void Preparator::prepare(std::size_t pos, Poco::Int64&) { } -void Preparation::prepare(std::size_t pos, Poco::UInt64&) +void Preparator::prepare(std::size_t pos, Poco::UInt64&) { } #ifndef POCO_LONG_IS_64_BIT -void Preparation::prepare(std::size_t pos, long&) +void Preparator::prepare(std::size_t pos, long&) { } #endif -void Preparation::prepare(std::size_t pos, bool&) +void Preparator::prepare(std::size_t pos, bool&) { } -void Preparation::prepare(std::size_t pos, float&) +void Preparator::prepare(std::size_t pos, float&) { } -void Preparation::prepare(std::size_t pos, double&) +void Preparator::prepare(std::size_t pos, double&) { } -void Preparation::prepare(std::size_t pos, char&) +void Preparator::prepare(std::size_t pos, char&) { } -void Preparation::prepare(std::size_t pos, const std::string&) +void Preparator::prepare(std::size_t pos, const std::string&) { } -void Preparation::prepare(std::size_t pos, const Poco::Data::BLOB&) +void Preparator::prepare(std::size_t pos, const Poco::Data::BLOB&) { } -void Preparation::prepare(std::size_t pos, const Poco::Data::Date&) +void Preparator::prepare(std::size_t pos, const Poco::Data::CLOB&) { } -void Preparation::prepare(std::size_t pos, const Poco::Data::Time&) +void Preparator::prepare(std::size_t pos, const Poco::Data::Date&) { } -void Preparation::prepare(std::size_t pos, const Poco::DateTime&) +void Preparator::prepare(std::size_t pos, const Poco::Data::Time&) { } -void Preparation::prepare(std::size_t pos, const Poco::Any&) +void Preparator::prepare(std::size_t pos, const Poco::DateTime&) { } -void Preparation::prepare(std::size_t pos, const Poco::Dynamic::Var&) +void Preparator::prepare(std::size_t pos, const Poco::Any&) +{ +} + + +void Preparator::prepare(std::size_t pos, const Poco::Dynamic::Var&) { } diff --git a/Data/testsuite/src/Preparation.h b/Data/testsuite/src/Preparator.h similarity index 67% rename from Data/testsuite/src/Preparation.h rename to Data/testsuite/src/Preparator.h index 86e8ede91..01640b0c8 100644 --- a/Data/testsuite/src/Preparation.h +++ b/Data/testsuite/src/Preparator.h @@ -1,9 +1,9 @@ // -// Preparation.h +// Preparator.h // -// $Id: //poco/Main/Data/testsuite/src/Preparation.h#3 $ +// $Id: //poco/Main/Data/testsuite/src/Preparator.h#3 $ // -// Definition of the Preparation class. +// Definition of the Preparator class. // // Copyright (c) 2006, Applied Informatics Software Engineering GmbH. // and Contributors. @@ -32,11 +32,11 @@ // -#ifndef Data_Test_Preparation_INCLUDED -#define Data_Test_Preparation_INCLUDED +#ifndef Data_Test_Preparator_INCLUDED +#define Data_Test_Preparator_INCLUDED -#include "Poco/Data/AbstractPreparation.h" +#include "Poco/Data/AbstractPreparator.h" #include "Poco/Any.h" @@ -45,81 +45,84 @@ namespace Data { namespace Test { -class Preparation: public Poco::Data::AbstractPreparation - /// A no-op implementation of AbstractPreparation for testing. +class Preparator: public Poco::Data::AbstractPreparator + /// A no-op implementation of AbstractPreparator for testing. { public: - Preparation(); - /// Creates the Preparation. + Preparator(); + /// Creates the Preparator. - ~Preparation(); - /// Destroys the Preparation. + ~Preparator(); + /// Destroys the Preparator. void prepare(std::size_t pos, Poco::Int8&); - /// Prepares an Int8. + /// Preparations an Int8. void prepare(std::size_t pos, Poco::UInt8&); - /// Prepares an UInt8. + /// Preparations an UInt8. void prepare(std::size_t pos, Poco::Int16&); - /// Prepares an Int16. + /// Preparations an Int16. void prepare(std::size_t pos, Poco::UInt16&); - /// Prepares an UInt16. + /// Preparations an UInt16. void prepare(std::size_t pos, Poco::Int32&); - /// Prepares an Int32. + /// Preparations an Int32. void prepare(std::size_t pos, Poco::UInt32&); - /// Prepares an UInt32. + /// Preparations an UInt32. void prepare(std::size_t pos, Poco::Int64&); - /// Prepares an Int64. + /// Preparations an Int64. void prepare(std::size_t pos, Poco::UInt64&); - /// Prepares an UInt64. + /// Preparations an UInt64. #ifndef POCO_LONG_IS_64_BIT void prepare(std::size_t pos, long&); - /// Prepares a long. + /// Preparations a long. #endif void prepare(std::size_t pos, bool&); - /// Prepares a boolean. + /// Preparations a boolean. void prepare(std::size_t pos, float&); - /// Prepares a float. + /// Preparations a float. void prepare(std::size_t pos, double&); - /// Prepares a double. + /// Preparations a double. void prepare(std::size_t pos, char&); - /// Prepares a single character. + /// Preparations a single character. void prepare(std::size_t pos, const std::string&); - /// Prepares a string. + /// Preparations a string. void prepare(std::size_t pos, const Poco::Data::BLOB&); - /// Prepares a BLOB. + /// Preparations a BLOB. + + void prepare(std::size_t pos, const Poco::Data::CLOB&); + /// Preparations a CLOB. void prepare(std::size_t pos, const Poco::Data::Date&); - /// Prepares a Date. + /// Preparations a Date. void prepare(std::size_t pos, const Poco::Data::Time&); - /// Prepares a Time. + /// Preparations a Time. void prepare(std::size_t pos, const Poco::DateTime&); - /// Prepares a DateTime. + /// Preparations a DateTime. void prepare(std::size_t pos, const Poco::Any&); - /// Prepares an Any. + /// Preparations an Any. void prepare(std::size_t pos, const Poco::Dynamic::Var&); - /// Prepares a Var. + /// Preparations a Var. }; } } } // namespace Poco::Data::Test -#endif // Data_Test_Preparation_INCLUDED +#endif // Data_Test_Preparator_INCLUDED diff --git a/Data/testsuite/src/TestStatementImpl.cpp b/Data/testsuite/src/TestStatementImpl.cpp index d729e8051..2233db906 100644 --- a/Data/testsuite/src/TestStatementImpl.cpp +++ b/Data/testsuite/src/TestStatementImpl.cpp @@ -56,7 +56,7 @@ void TestStatementImpl::compileImpl() // prepare binding _ptrBinder = new Binder; _ptrExtractor = new Extractor; - _ptrPrepare = new Preparation; + _ptrPreparation = new Preparator; _compiled = true; } diff --git a/Data/testsuite/src/TestStatementImpl.h b/Data/testsuite/src/TestStatementImpl.h index 7435bc648..1f7dffc35 100644 --- a/Data/testsuite/src/TestStatementImpl.h +++ b/Data/testsuite/src/TestStatementImpl.h @@ -41,7 +41,7 @@ #include "Poco/SharedPtr.h" #include "Binder.h" #include "Extractor.h" -#include "Preparation.h" +#include "Preparator.h" namespace Poco { @@ -99,10 +99,10 @@ protected: /// Returns the concrete binder used by the statement. private: - Poco::SharedPtr _ptrBinder; - Poco::SharedPtr _ptrExtractor; - Poco::SharedPtr _ptrPrepare; - bool _compiled; + Poco::SharedPtr _ptrBinder; + Poco::SharedPtr _ptrExtractor; + Poco::SharedPtr _ptrPreparation; + bool _compiled; };