mirror of
https://github.com/Telecominfraproject/wlan-cloud-lib-poco.git
synced 2025-11-04 04:28:10 +00:00
866 lines
19 KiB
C++
866 lines
19 KiB
C++
//
|
|
// Extraction.h
|
|
//
|
|
// $Id: //poco/Main/Data/include/Poco/Data/Extraction.h#9 $
|
|
//
|
|
// Library: Data
|
|
// Package: DataCore
|
|
// Module: Extraction
|
|
//
|
|
// Definition of the Extraction class.
|
|
//
|
|
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
|
|
// and Contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person or organization
|
|
// obtaining a copy of the software and accompanying documentation covered by
|
|
// this license (the "Software") to use, reproduce, display, distribute,
|
|
// execute, and transmit the Software, and to prepare derivative works of the
|
|
// Software, and to permit third-parties to whom the Software is furnished to
|
|
// do so, all subject to the following:
|
|
//
|
|
// The copyright notices in the Software and this entire statement, including
|
|
// the above license grant, this restriction and the following disclaimer,
|
|
// must be included in all copies of the Software, in whole or in part, and
|
|
// all derivative works of the Software, unless such copies or derivative
|
|
// works are solely in the form of machine-executable object code generated by
|
|
// a source language processor.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
|
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
|
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
|
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
// DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
|
|
#ifndef Data_Extraction_INCLUDED
|
|
#define Data_Extraction_INCLUDED
|
|
|
|
|
|
#include "Poco/Data/Data.h"
|
|
#include "Poco/Data/AbstractExtraction.h"
|
|
#include "Poco/Data/Preparation.h"
|
|
#include "Poco/Data/TypeHandler.h"
|
|
#include "Poco/Data/Column.h"
|
|
#include "Poco/Data/Position.h"
|
|
#include "Poco/Data/DataException.h"
|
|
#include <set>
|
|
#include <vector>
|
|
#include <list>
|
|
#include <deque>
|
|
#include <map>
|
|
#include <cstddef>
|
|
|
|
|
|
namespace Poco {
|
|
namespace Data {
|
|
|
|
|
|
template <class T>
|
|
class Extraction: public AbstractExtraction
|
|
/// Concrete Data Type specific extraction of values from a query result set.
|
|
{
|
|
public:
|
|
typedef T ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
Extraction(T& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(),
|
|
_extracted(false)
|
|
/// Creates an Extraction object at specified position.
|
|
/// Uses an empty object T as default value.
|
|
{
|
|
}
|
|
|
|
Extraction(T& result, const T& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def),
|
|
_extracted(false)
|
|
/// Creates an Extraction object at specified position.
|
|
/// Uses the provided def object as default value.
|
|
{
|
|
}
|
|
|
|
~Extraction()
|
|
/// Destroys the Extraction object.
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<T>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return _extracted ? 1u : 0;
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return 1u;
|
|
}
|
|
|
|
bool isNull(std::size_t row = 0) const
|
|
{
|
|
return _null;
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
if (_extracted) throw ExtractException("value already extracted");
|
|
_extracted = true;
|
|
AbstractExtractor::Ptr pExt = getExtractor();
|
|
TypeHandler<T>::extract(pos, _rResult, _default, pExt);
|
|
_null = isValueNull<T>(_rResult, pExt->isNull(pos));
|
|
|
|
return 1u;
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
_extracted = false;
|
|
}
|
|
|
|
bool canExtract() const
|
|
{
|
|
return !_extracted;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<T>(pPrep, pos, _rResult);
|
|
}
|
|
|
|
private:
|
|
T& _rResult;
|
|
T _default;
|
|
bool _extracted;
|
|
bool _null;
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class Extraction<std::vector<T> >: public AbstractExtraction
|
|
/// Vector Data Type specialization for extraction of values from a query result set.
|
|
{
|
|
public:
|
|
|
|
typedef std::vector<T> ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
Extraction(std::vector<T>& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default()
|
|
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
Extraction(std::vector<T>& result, const T& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def)
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
virtual ~Extraction()
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<T>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return static_cast<std::size_t>(_rResult.size());
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return getLimit();
|
|
}
|
|
|
|
bool isNull(std::size_t row) const
|
|
{
|
|
try
|
|
{
|
|
return _nulls.at(row);
|
|
}catch (std::out_of_range& ex)
|
|
{
|
|
throw RangeException(ex.what());
|
|
}
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
AbstractExtractor::Ptr pExt = getExtractor();
|
|
_rResult.push_back(_default);
|
|
TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
|
|
_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
|
|
return 1u;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<T>(pPrep, pos, _default);
|
|
}
|
|
|
|
protected:
|
|
|
|
const std::vector<T>& result() const
|
|
{
|
|
return _rResult;
|
|
}
|
|
|
|
private:
|
|
std::vector<T>& _rResult;
|
|
T _default;
|
|
std::deque<bool> _nulls;
|
|
};
|
|
|
|
|
|
template <>
|
|
class Extraction<std::vector<bool> >: public AbstractExtraction
|
|
/// Vector bool specialization for extraction of values from a query result set.
|
|
{
|
|
public:
|
|
typedef std::vector<bool> ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
Extraction(std::vector<bool>& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default()
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
Extraction(std::vector<bool>& result, const bool& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def)
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
virtual ~Extraction()
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<bool>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return static_cast<std::size_t>(_rResult.size());
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return getLimit();
|
|
}
|
|
|
|
bool isNull(std::size_t row) const
|
|
{
|
|
try
|
|
{
|
|
return _nulls.at(row);
|
|
}catch (std::out_of_range& ex)
|
|
{
|
|
throw RangeException(ex.what());
|
|
}
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
AbstractExtractor::Ptr pExt = getExtractor();
|
|
|
|
bool tmp = _default;
|
|
TypeHandler<bool>::extract(pos, tmp, _default, pExt);
|
|
_rResult.push_back(tmp);
|
|
_nulls.push_back(pExt->isNull(pos));
|
|
return 1u;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<bool>(pPrep, pos, _default);
|
|
}
|
|
|
|
protected:
|
|
|
|
const std::vector<bool>& result() const
|
|
{
|
|
return _rResult;
|
|
}
|
|
|
|
private:
|
|
std::vector<bool>& _rResult;
|
|
bool _default;
|
|
std::deque<bool> _nulls;
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class Extraction<std::list<T> >: public AbstractExtraction
|
|
/// List Data Type specialization for extraction of values from a query result set.
|
|
{
|
|
public:
|
|
typedef std::list<T> ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
Extraction(std::list<T>& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default()
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
Extraction(std::list<T>& result, const T& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def)
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
virtual ~Extraction()
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<T>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return _rResult.size();
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return getLimit();
|
|
}
|
|
|
|
bool isNull(std::size_t row) const
|
|
{
|
|
try
|
|
{
|
|
return _nulls.at(row);
|
|
}catch (std::out_of_range& ex)
|
|
{
|
|
throw RangeException(ex.what());
|
|
}
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
AbstractExtractor::Ptr pExt = getExtractor();
|
|
_rResult.push_back(_default);
|
|
TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
|
|
_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
|
|
return 1u;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<T>(pPrep, pos, _default);
|
|
}
|
|
|
|
protected:
|
|
|
|
const std::list<T>& result() const
|
|
{
|
|
return _rResult;
|
|
}
|
|
|
|
private:
|
|
std::list<T>& _rResult;
|
|
T _default;
|
|
std::deque<bool> _nulls;
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class Extraction<std::deque<T> >: public AbstractExtraction
|
|
/// Deque Data Type specialization for extraction of values from a query result set.
|
|
{
|
|
public:
|
|
typedef std::deque<T> ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
Extraction(std::deque<T>& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default()
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
Extraction(std::deque<T>& result, const T& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def)
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
virtual ~Extraction()
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<T>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return _rResult.size();
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return getLimit();
|
|
}
|
|
|
|
bool isNull(std::size_t row) const
|
|
{
|
|
try
|
|
{
|
|
return _nulls.at(row);
|
|
}catch (std::out_of_range& ex)
|
|
{
|
|
throw RangeException(ex.what());
|
|
}
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
AbstractExtractor::Ptr pExt = getExtractor();
|
|
_rResult.push_back(_default);
|
|
TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
|
|
_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
|
|
return 1u;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<T>(pPrep, pos, _default);
|
|
}
|
|
|
|
protected:
|
|
|
|
const std::deque<T>& result() const
|
|
{
|
|
return _rResult;
|
|
}
|
|
|
|
private:
|
|
std::deque<T>& _rResult;
|
|
T _default;
|
|
std::deque<bool> _nulls;
|
|
};
|
|
|
|
|
|
template <class C>
|
|
class InternalExtraction: public Extraction<C>
|
|
/// Container Data Type specialization extension for extraction of values from a query result set.
|
|
///
|
|
/// This class is intended for PocoData internal use - it is used by StatementImpl
|
|
/// to automaticaly create internal Extraction in cases when statement returns data and no external storage
|
|
/// was supplied. It is later used by RecordSet to retrieve the fetched data after statement execution.
|
|
/// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn
|
|
/// owns the data container pointer.
|
|
///
|
|
/// InternalExtraction objects can not be copied or assigned.
|
|
{
|
|
public:
|
|
typedef typename C::value_type ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
|
|
explicit InternalExtraction(C& result, Column<C>* pColumn, const Position& pos = Position(0)):
|
|
Extraction<C>(result, ValType(), pos),
|
|
_pColumn(pColumn)
|
|
/// Creates InternalExtraction.
|
|
{
|
|
}
|
|
|
|
~InternalExtraction()
|
|
/// Destroys InternalExtraction.
|
|
{
|
|
delete _pColumn;
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
_pColumn->reset();
|
|
}
|
|
|
|
const ValType& value(int index) const
|
|
{
|
|
try
|
|
{
|
|
return Extraction<C>::result().at(index);
|
|
}
|
|
catch (std::out_of_range& ex)
|
|
{
|
|
throw RangeException(ex.what());
|
|
}
|
|
}
|
|
|
|
bool isNull(std::size_t row) const
|
|
{
|
|
return Extraction<C>::isNull(row);
|
|
}
|
|
|
|
const Column<C>& column() const
|
|
{
|
|
return *_pColumn;
|
|
}
|
|
|
|
private:
|
|
InternalExtraction();
|
|
InternalExtraction(const InternalExtraction&);
|
|
InternalExtraction& operator = (const InternalExtraction&);
|
|
|
|
Column<C>* _pColumn;
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class Extraction<std::set<T> >: public AbstractExtraction
|
|
/// Set Data Type specialization for extraction of values from a query result set.
|
|
{
|
|
public:
|
|
typedef std::set<T> ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
typedef typename ValType::iterator Iterator;
|
|
|
|
Extraction(std::set<T>& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default()
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
Extraction(std::set<T>& result, const T& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def)
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
~Extraction()
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<T>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return static_cast<std::size_t>(_rResult.size());
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return getLimit();
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
T tmp;
|
|
TypeHandler<T>::extract(pos, tmp, _default, getExtractor());
|
|
_rResult.insert(tmp);
|
|
return 1u;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<T>(pPrep, pos, _default);
|
|
}
|
|
|
|
private:
|
|
std::set<T>& _rResult;
|
|
T _default;
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class Extraction<std::multiset<T> >: public AbstractExtraction
|
|
/// Multiset Data Type specialization for extraction of values from a query result set.
|
|
{
|
|
public:
|
|
typedef std::multiset<T> ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
Extraction(std::multiset<T>& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default()
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
Extraction(std::multiset<T>& result, const T& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def)
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
~Extraction()
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<T>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return static_cast<std::size_t>(_rResult.size());
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return getLimit();
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
T tmp;
|
|
TypeHandler<T>::extract(pos, tmp, _default, getExtractor());
|
|
_rResult.insert(tmp);
|
|
return 1u;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<T>(pPrep, pos, _default);
|
|
}
|
|
|
|
private:
|
|
std::multiset<T>& _rResult;
|
|
T _default;
|
|
};
|
|
|
|
|
|
template <class K, class V>
|
|
class Extraction<std::map<K, V> >: public AbstractExtraction
|
|
/// Map Data Type specialization for extraction of values from a query result set.
|
|
{
|
|
public:
|
|
typedef std::map<K, V> ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
Extraction(std::map<K, V>& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default()
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
Extraction(std::map<K, V>& result, const V& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def)
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
~Extraction()
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<V>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return static_cast<std::size_t>(_rResult.size());
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return getLimit();
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
V tmp;
|
|
TypeHandler<V>::extract(pos, tmp, _default, getExtractor());
|
|
_rResult.insert(std::make_pair(tmp(), tmp));
|
|
return 1u;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<V>(pPrep, pos, _default);
|
|
}
|
|
|
|
private:
|
|
std::map<K, V>& _rResult;
|
|
V _default;
|
|
};
|
|
|
|
|
|
template <class K, class V>
|
|
class Extraction<std::multimap<K, V> >: public AbstractExtraction
|
|
/// Multimap Data Type specialization for extraction of values from a query result set.
|
|
{
|
|
public:
|
|
typedef std::multimap<K, V> ValType;
|
|
typedef SharedPtr<ValType> ValPtr;
|
|
typedef Extraction<ValType> Type;
|
|
typedef SharedPtr<Type> Ptr;
|
|
|
|
Extraction(std::multimap<K, V>& result, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default()
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
Extraction(std::multimap<K, V>& result, const V& def, const Position& pos = Position(0)):
|
|
AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
|
|
_rResult(result),
|
|
_default(def)
|
|
{
|
|
_rResult.clear();
|
|
}
|
|
|
|
~Extraction()
|
|
{
|
|
}
|
|
|
|
std::size_t numOfColumnsHandled() const
|
|
{
|
|
return TypeHandler<V>::size();
|
|
}
|
|
|
|
std::size_t numOfRowsHandled() const
|
|
{
|
|
return static_cast<std::size_t>(_rResult.size());
|
|
}
|
|
|
|
std::size_t numOfRowsAllowed() const
|
|
{
|
|
return getLimit();
|
|
}
|
|
|
|
std::size_t extract(std::size_t pos)
|
|
{
|
|
V tmp;
|
|
TypeHandler<V>::extract(pos, tmp, _default, getExtractor());
|
|
_rResult.insert(std::make_pair(tmp(), tmp));
|
|
return 1u;
|
|
}
|
|
|
|
AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
|
|
{
|
|
return new Preparation<V>(pPrep, pos, _default);
|
|
}
|
|
|
|
private:
|
|
std::multimap<K, V>& _rResult;
|
|
V _default;
|
|
};
|
|
|
|
|
|
namespace Keywords {
|
|
|
|
|
|
template <typename T>
|
|
inline AbstractExtraction::Ptr into(T& t)
|
|
/// Convenience function to allow for a more compact creation of an extraction object.
|
|
{
|
|
return new Extraction<T>(t);
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline AbstractExtraction::Ptr into(T& t, const Position& pos)
|
|
/// Convenience function to allow for a more compact creation of an extraction object
|
|
/// with multiple recordset support.
|
|
{
|
|
return new Extraction<T>(t, pos);
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline AbstractExtraction::Ptr into(T& t, const Position& pos, const T& def)
|
|
/// Convenience function to allow for a more compact creation of an extraction object
|
|
/// with multiple recordset support and the given default
|
|
{
|
|
return new Extraction<T>(t, def, pos);
|
|
}
|
|
|
|
|
|
inline AbstractExtractionVecVec& into(AbstractExtractionVecVec& evv)
|
|
/// Convenience dummy function (for syntax purposes only).
|
|
{
|
|
return evv;
|
|
}
|
|
|
|
|
|
inline AbstractExtractionVec& into(AbstractExtractionVec& ev)
|
|
/// Convenience dummy function (for syntax purposes only).
|
|
{
|
|
return ev;
|
|
}
|
|
|
|
|
|
} // namespace Keywords
|
|
|
|
|
|
} } // namespace Poco::Data
|
|
|
|
|
|
#endif // Data_Extraction_INCLUDED
|