#pragma once // ------------------------------------------------------------------------------------------------ #include "Library/IO/Buffer.hpp" #include "Library/Utils/String.hpp" #include "Library/Utils/Vector.hpp" // ------------------------------------------------------------------------------------------------ #include #include #include #include #include #include // ------------------------------------------------------------------------------------------------ namespace std { // NOLINT(cert-dcl58-cpp) /* ------------------------------------------------------------------------------------------------ * Allows the StackStrF to write its data into a std::ostream type. */ inline std::ostream & operator << (std::ostream & out, const ::Sqrat::StackStrF & str) { if (str.mLen) { out.write(str.mPtr, str.mLen); } return out; } /* ------------------------------------------------------------------------------------------------ * Allows the StackStrF to write its data into a std::ostringstream type. */ inline std::ostringstream & operator << (std::ostringstream & out, const ::Sqrat::StackStrF & str) { if (str.mLen) { out.write(str.mPtr, str.mLen); } return out; } } // Namespace:: std // ------------------------------------------------------------------------------------------------ namespace Poco { // NOLINT(modernize-concat-nested-namespaces) namespace Data { /* ------------------------------------------------------------------------------------------------ * Implementation of AbstractBinding for shared ownership binding of values. * Because we cannot take references to script variables, we use this as a proxy. */ template struct ReferenceBinding : public AbstractBinding { using ValType = T; using ValPtr = SharedPtr; using Type = ReferenceBinding; using Ptr = SharedPtr; /* -------------------------------------------------------------------------------------------- * Base constructor. */ explicit ReferenceBinding(const ValPtr& val, const std::string& name = "", Direction direction = PD_IN) : AbstractBinding(name, direction), m_Value(val), m_Bound(false) { } /* -------------------------------------------------------------------------------------------- * Destructor. */ ~ReferenceBinding() override = default; /* -------------------------------------------------------------------------------------------- * Retrieve columns occupied. */ SQMOD_NODISCARD std::size_t numOfColumnsHandled() const override { return TypeHandler::size(); } /* -------------------------------------------------------------------------------------------- * Retrieve rows occupied. */ SQMOD_NODISCARD std::size_t numOfRowsHandled() const override { return 1; } /* -------------------------------------------------------------------------------------------- * Check if binding is available. */ SQMOD_NODISCARD bool canBind() const override { return !m_Bound; } /* -------------------------------------------------------------------------------------------- * Bind the value. */ void bind(std::size_t pos) override { poco_assert_dbg(!getBinder().isNull()); TypeHandler::bind(pos, *m_Value, getBinder(), getDirection()); m_Bound = true; } /* -------------------------------------------------------------------------------------------- * Reset the binding. */ void reset() override { m_Bound = false; AbstractBinder::Ptr pBinder = getBinder(); poco_assert_dbg (!pBinder.isNull()); pBinder->reset(); } private: ValPtr m_Value; bool m_Bound; }; /* ------------------------------------------------------------------------------------------------ * Implementation of AbstractBinding for shared ownership binding of values. * Because we cannot take references to script variables, we use this as a proxy. */ template struct ReferenceBinding> : public AbstractBinding { using ValType = std::vector; using ValPtr = SharedPtr; using Ptr = SharedPtr>; using Iterator = typename ValType::const_iterator; /* -------------------------------------------------------------------------------------------- * Base constructor. */ explicit ReferenceBinding(const ValPtr& val, const std::string& name = "", Direction direction = PD_IN) : AbstractBinding(name, direction), m_Value(val), m_Begin(), m_End() { if (PD_IN == direction && m_Value->size() == 0) { throw BindingException("It is illegal to bind to an empty data collection"); } m_Begin = m_Value->begin(); m_End = m_Value->end(); } /* -------------------------------------------------------------------------------------------- * Destructor. */ ~ReferenceBinding() override = default; /* -------------------------------------------------------------------------------------------- * Retrieve columns occupied. */ SQMOD_NODISCARD std::size_t numOfColumnsHandled() const override { return TypeHandler::size(); } /* -------------------------------------------------------------------------------------------- * Retrieve rows occupied. */ SQMOD_NODISCARD std::size_t numOfRowsHandled() const override { return m_Value->size(); } /* -------------------------------------------------------------------------------------------- * Check if binding is available. */ SQMOD_NODISCARD bool canBind() const override { return (m_Begin != m_End); } /* -------------------------------------------------------------------------------------------- * Bind the value. */ void bind(std::size_t pos) override { poco_assert_dbg(!getBinder().isNull()); poco_assert_dbg(canBind()); TypeHandler::bind(pos, *m_Begin, getBinder(), getDirection()); ++m_Begin; } /* -------------------------------------------------------------------------------------------- * Reset the binding. */ void reset() override { m_Begin = m_Value->begin(); m_End = m_Value->end(); } private: ValPtr m_Value; Iterator m_Begin; Iterator m_End; }; /* ------------------------------------------------------------------------------------------------ * Implementation of AbstractExtraction for shared ownership binding of values. * Because we cannot take references to script variables, we use this as a proxy. */ template class ReferenceExtraction: public AbstractExtraction { public: using ValType = T; using Result = SharedPtr; using ValPtr = SharedPtr; using Type = Extraction; using Ptr = SharedPtr; /* -------------------------------------------------------------------------------------------- * Creates an Extraction object at specified position. Uses an empty object T as default value. */ explicit ReferenceExtraction(const Result& result, const Position& pos = Position(0)) : AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()) , m_Result(result),m_Default(),m_Extracted(false),m_Null(false) { } /* -------------------------------------------------------------------------------------------- * Creates an Extraction object at specified position. Uses the provided def object as default value. */ ReferenceExtraction(const Result& result, const T& def, const Position& pos = Position(0)) : AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()) , m_Result(result), m_Default(def), m_Extracted(false), m_Null(false) { } /* -------------------------------------------------------------------------------------------- * Creates an Extraction object at specified position. Uses the provided def object as default value. */ ReferenceExtraction(const Result& result, T&& def, const Position& pos = Position(0)) : AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()) , m_Result(result), m_Default(std::move(def)), m_Extracted(false), m_Null(false) { } /* -------------------------------------------------------------------------------------------- * Destroys the Extraction object. */ ~ReferenceExtraction() override = default; /* -------------------------------------------------------------------------------------------- * Retrieve the number of columns handled. */ SQMOD_NODISCARD std::size_t numOfColumnsHandled() const override { return TypeHandler::size(); } /* -------------------------------------------------------------------------------------------- * Retrieve the number of rows handled. */ SQMOD_NODISCARD std::size_t numOfRowsHandled() const override { return m_Extracted ? 1u : 0; } /* -------------------------------------------------------------------------------------------- * Retrieve the number of rows allowed. */ SQMOD_NODISCARD std::size_t numOfRowsAllowed() const override { return 1u; } /* -------------------------------------------------------------------------------------------- * Check if null. */ SQMOD_NODISCARD bool isNull(std::size_t /*row*/) const override { return m_Null; } /* -------------------------------------------------------------------------------------------- * Extract the value. */ std::size_t extract(std::size_t pos) override { if (m_Extracted) { throw ExtractException("value already extracted"); } m_Extracted = true; AbstractExtractor::Ptr pExt = getExtractor(); TypeHandler::extract(pos, *m_Result, m_Default, pExt); m_Null = isValueNull(*m_Result, pExt->isNull(pos)); return 1u; } /* -------------------------------------------------------------------------------------------- * Reset state. */ void reset() override { m_Extracted = false; } /* -------------------------------------------------------------------------------------------- * See if a value was extracted. */ SQMOD_NODISCARD bool canExtract() const override { return !m_Extracted; } /* -------------------------------------------------------------------------------------------- * Create a preparation instance for this type. */ AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos) override { return new Preparation(pPrep, pos, *m_Result); } private: Result m_Result; T m_Default; bool m_Extracted; bool m_Null; }; /* ------------------------------------------------------------------------------------------------ * Implementation of AbstractExtraction for shared ownership binding of values. * Because we cannot take references to script variables, we use this as a proxy. */ template class ReferenceExtraction>: public AbstractExtraction { public: using ValType = std::vector; using Result = SharedPtr>; using ValPtr = SharedPtr; using Type = Extraction; using Ptr = SharedPtr; /* -------------------------------------------------------------------------------------------- * Creates an Extraction object at specified position. Uses an empty object T as default value. */ explicit ReferenceExtraction(const Result& result, const Position& pos = Position(0)) : AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()) , m_Result(result), m_Default(), m_Nulls() { m_Result->clear(); } /* -------------------------------------------------------------------------------------------- * Creates an Extraction object at specified position. Uses the provided def object as default value. */ ReferenceExtraction(const Result& result, const T& def, const Position& pos = Position(0)) : AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()) , m_Result(result), m_Default(def), m_Nulls() { m_Result->clear(); } /* -------------------------------------------------------------------------------------------- * Destroys the Extraction object. */ ~ReferenceExtraction() override = default; /* -------------------------------------------------------------------------------------------- * Retrieve the number of columns handled. */ SQMOD_NODISCARD std::size_t numOfColumnsHandled() const override { return TypeHandler::size(); } /* -------------------------------------------------------------------------------------------- * Retrieve the number of rows handled. */ SQMOD_NODISCARD std::size_t numOfRowsHandled() const override { return static_cast(m_Result->size()); } /* -------------------------------------------------------------------------------------------- * Retrieve the number of rows allowed. */ SQMOD_NODISCARD std::size_t numOfRowsAllowed() const override { return getLimit(); } /* -------------------------------------------------------------------------------------------- * Check if null. */ SQMOD_NODISCARD bool isNull(std::size_t row) const override { try { return m_Nulls.at(row); } catch (std::out_of_range& ex) { throw RangeException(ex.what()); } } /* -------------------------------------------------------------------------------------------- * Extract the value. */ std::size_t extract(std::size_t pos) override { AbstractExtractor::Ptr ext = getExtractor(); m_Result->push_back(m_Default); TypeHandler::extract(pos, m_Result->back(), m_Default, ext); m_Nulls.push_back(isValueNull(m_Result->back(), ext->isNull(pos))); return 1u; } /* -------------------------------------------------------------------------------------------- * Create a preparation instance for this type. */ AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos) override { return new Preparation(pPrep, pos, m_Default); } /* -------------------------------------------------------------------------------------------- * Reset state. */ void reset() override { m_Nulls.clear(); } protected: /* -------------------------------------------------------------------------------------------- * Retrieve the container with the extracted values. */ SQMOD_NODISCARD const std::vector& result() const { return *m_Result; } private: Result m_Result; T m_Default; std::deque< bool > m_Nulls; }; // ------------------------------------------------------------------------------------------------ template <> std::size_t ReferenceExtraction< std::vector >::extract(std::size_t pos) { AbstractExtractor::Ptr ext = getExtractor(); bool tmp = m_Default; TypeHandler::extract(pos, tmp, m_Default, ext); m_Result->push_back(tmp); m_Nulls.push_back(ext->isNull(pos)); return 1u; } } // Namespace:: Data } // Namespace:: Poco // ------------------------------------------------------------------------------------------------ namespace SqMod { // ------------------------------------------------------------------------------------------------ using namespace Poco::Data::Keywords; // ------------------------------------------------------------------------------------------------ using Poco::Data::Session; using Poco::Data::Statement; using Poco::Data::RecordSet; using Poco::Data::Transaction; using Poco::Data::SessionPool; using Poco::Data::ReferenceBinding; // ------------------------------------------------------------------------------------------------ struct SqDataSession; struct SqDataStatement; struct SqDataRecordSet; /* ------------------------------------------------------------------------------------------------ * Utility used to transform optimal argument type to stored type. */ template < class T > struct SqDataBindingOpt { /* -------------------------------------------------------------------------------------------- * Optimal argument type. Unchanged when not specialized. */ using Type = T; /* -------------------------------------------------------------------------------------------- * Convert the optimal type to the stored type. Does nothing special in this case. */ inline static Type & Get(Type & v) { return v; } inline static const Type & Get(const Type & v) { return v; } // -------------------------------------------------------------------------------------------- inline static void Put(T & o, Type & v) { o = v; } inline static void Put(T & o, const Type & v) { o = v; } }; /* ------------------------------------------------------------------------------------------------ * Specialization of SqDataBindingOpt for std::string type. */ template < > struct SqDataBindingOpt< String > { /* -------------------------------------------------------------------------------------------- * Optimal argument type. */ using Type = StackStrF; /* -------------------------------------------------------------------------------------------- * Convert the optimal type to the stored type. */ inline static String Get(Type & v) { return v.ToStr(); } inline static String Get(const Type & v) { return v.ToStr(); } // -------------------------------------------------------------------------------------------- inline static void Put(String & o, Type & v) { o.assign(v.mPtr, v.GetSize()); } inline static void Put(String & o, const Type & v) { o.assign(v.mPtr, v.GetSize()); } }; /* ------------------------------------------------------------------------------------------------ * Wrapper around values that must be passed as reference. Manual lifetime management! */ template < class T > struct SqDataBinding { /* -------------------------------------------------------------------------------------------- * Reference binding type. */ using Binding = ReferenceBinding< T >; /* -------------------------------------------------------------------------------------------- * Optimal type to receive a value of this type as function argument. Mainly for strings. */ using OptimalType = typename SqDataBindingOpt< T >::Type; /* -------------------------------------------------------------------------------------------- * Same as OptimalType but preferably with a reference qualifier to avoid copies. */ using OptimalArg = typename std::conditional< std::is_same< T, OptimalType >::value, T, OptimalType & >::type; /* -------------------------------------------------------------------------------------------- * Reference value. */ typename Binding::ValPtr mV{}; /* -------------------------------------------------------------------------------------------- * Default constructor. Initializes to a default value. */ SqDataBinding() : mV(new T()) { } /* -------------------------------------------------------------------------------------------- * Explicit constructor. Initializes to a specific value. */ explicit SqDataBinding(OptimalArg v) : mV(new T()) { SqDataBindingOpt< T >::Put(*mV, v); } /* -------------------------------------------------------------------------------------------- * Copy constructor. */ SqDataBinding(const SqDataBinding &) = default; /* -------------------------------------------------------------------------------------------- * Move constructor. */ SqDataBinding(SqDataBinding &&) noexcept = default; /* -------------------------------------------------------------------------------------------- * Destroys the Statement. */ ~SqDataBinding() = default; /* -------------------------------------------------------------------------------------------- * Assignment operator. */ SqDataBinding & operator = (const SqDataBinding &) = default; /* -------------------------------------------------------------------------------------------- * Move assignment. */ SqDataBinding & operator = (SqDataBinding &&) noexcept = default; /* -------------------------------------------------------------------------------------------- * Retrieve a value from the instance. */ SQMOD_NODISCARD const T & Get() const { return *mV; } /* -------------------------------------------------------------------------------------------- * Modify a value from the instance. */ void Set(OptimalArg v) { SqDataBindingOpt< T >::Put(*mV, v); } /* -------------------------------------------------------------------------------------------- * Modify a value from the instance. */ SqDataBinding & SetEx(OptimalArg v) { SqDataBindingOpt< T >::Put(*mV, v); return *this; } /* -------------------------------------------------------------------------------------------- * Use the value to a statement. */ SqDataBinding & Use(SqDataStatement & stmt); /* -------------------------------------------------------------------------------------------- * Use the value to a statement with a specific name. */ SqDataBinding & UseAs(SqDataStatement & stmt, StackStrF & name); /* -------------------------------------------------------------------------------------------- * Bind the value to a statement. */ SqDataBinding & Bind(SqDataStatement & stmt); /* -------------------------------------------------------------------------------------------- * Bind the value to a statement with a specific name. */ SqDataBinding & BindAs(SqDataStatement & stmt, StackStrF & name); }; /* ------------------------------------------------------------------------------------------------ * A Session holds a connection to a Database and creates Statement objects. */ struct SqDataSession : public Session { /* -------------------------------------------------------------------------------------------- * Creates a new session, using the given connection (must be in "connection:///info" format). */ SqDataSession(StackStrF & conn, SQInteger timeout) : Session(conn.ToStr(), ConvTo< size_t >::From(timeout)) { } /* -------------------------------------------------------------------------------------------- * Creates a new session, using the given connector, and connection information. */ SqDataSession(StackStrF & conn, StackStrF & info, SQInteger timeout) : Session(conn.ToStr(), info.ToStr(), ConvTo< size_t >::From(timeout)) { } /* -------------------------------------------------------------------------------------------- * Creates a session by copying another one. */ SqDataSession(const SqDataSession &) = default; /* -------------------------------------------------------------------------------------------- * Creates a session by moving another one. */ SqDataSession(SqDataSession &&) noexcept = default; /* -------------------------------------------------------------------------------------------- * Creates a session by copying another one. */ SqDataSession(const Session & s) : Session(s) { } /* -------------------------------------------------------------------------------------------- * Creates a session by moving another one. */ SqDataSession(Session && s) noexcept : Session(std::move(s)) { } /* -------------------------------------------------------------------------------------------- * Destroys the Session. */ ~SqDataSession() = default; /* -------------------------------------------------------------------------------------------- * Assignment operator. */ SqDataSession & operator = (const SqDataSession &) = default; /* -------------------------------------------------------------------------------------------- * Move assignment. */ SqDataSession & operator = (SqDataSession &&) noexcept = default; #ifdef SQMOD_POCO_HAS_MYSQL /* -------------------------------------------------------------------------------------------- * Implements string escape in MySQL. */ LightObj MySQLEscapeString(StackStrF & str); #endif /* -------------------------------------------------------------------------------------------- * Opens the session using the supplied string. * Can also be used with default empty string to reconnect a disconnected session. */ void Open(StackStrF & connect) { open(connect.ToStr()); } /* -------------------------------------------------------------------------------------------- * Closes the session. */ void Close() { close(); } /* -------------------------------------------------------------------------------------------- * Returns true if session is connected, false otherwise. */ bool IsConnected() { return isConnected(); } /* -------------------------------------------------------------------------------------------- * Closes the session and opens it. */ void Reconnect() { return reconnect(); } /* -------------------------------------------------------------------------------------------- * Returns true if the session is good and can be used, false otherwise. */ SQMOD_NODISCARD bool IsGood() { return isGood(); } /* -------------------------------------------------------------------------------------------- * Sets the session login timeout value. */ void SetLoginTimeout(SQInteger timeout) { setLoginTimeout(ConvTo< size_t >::From(timeout)); } /* -------------------------------------------------------------------------------------------- * Returns the session login timeout value. */ SQMOD_NODISCARD SQInteger GetLoginTimeout() const { return static_cast< SQInteger >(getLoginTimeout()); } /* -------------------------------------------------------------------------------------------- * Sets the session connection timeout value. */ void SetConnectionTimeout(SQInteger timeout) { setConnectionTimeout(ConvTo< size_t >::From(timeout)); } /* -------------------------------------------------------------------------------------------- * Returns the session connection timeout value. */ SQInteger GetConnectionTimeout() { return static_cast< SQInteger >(getConnectionTimeout()); } /* -------------------------------------------------------------------------------------------- * Starts a transaction. */ void Begin() { begin(); } /* -------------------------------------------------------------------------------------------- * Commits and ends a transaction. */ void Commit() { commit(); } /* -------------------------------------------------------------------------------------------- * Rolls back and ends a transaction. */ void Rollback() { rollback(); } /* -------------------------------------------------------------------------------------------- * Returns true if session has transaction capabilities. */ SQMOD_NODISCARD bool CanTransact() { return canTransact(); } /* -------------------------------------------------------------------------------------------- * Returns true if a transaction is in progress, false otherwise. */ SQMOD_NODISCARD bool IsTransaction() { return isTransaction(); } /* -------------------------------------------------------------------------------------------- * Sets the transaction isolation level. */ void SetTransactionIsolation(SQInteger ti) { setTransactionIsolation(static_cast< uint32_t >(ti)); } /* -------------------------------------------------------------------------------------------- * Returns the transaction isolation level. */ SQMOD_NODISCARD SQInteger GetTransactionIsolation() { return static_cast< SQInteger >(getTransactionIsolation()); } /* -------------------------------------------------------------------------------------------- * Returns true if the transaction isolation level corresponding to the supplied bitmask is supported. */ bool HasTransactionIsolation(SQInteger ti) { return hasTransactionIsolation(static_cast< uint32_t >(ti)); } /* -------------------------------------------------------------------------------------------- * Returns true if the transaction isolation level corresponds to the supplied bitmask. */ bool IsTransactionIsolation(SQInteger ti) { return isTransactionIsolation(static_cast< uint32_t >(ti)); } /* -------------------------------------------------------------------------------------------- * Returns the connector name for this session. */ SQMOD_NODISCARD std::string GetConnector() const { return connector(); } /* -------------------------------------------------------------------------------------------- * Returns the URI for this session. */ SQMOD_NODISCARD std::string GetURI() const { return uri(); } /* -------------------------------------------------------------------------------------------- * Utility function that teturns the URI formatted from supplied arguments as "connector:///info". */ SQMOD_NODISCARD static std::string BuildURI(StackStrF & connector, StackStrF & info) { return uri(connector.ToStr(), info.ToStr()); } /* -------------------------------------------------------------------------------------------- * Set the state of a feature. */ void SetFeature(bool state, StackStrF & name) { setFeature(name.ToStr(), state); } /* -------------------------------------------------------------------------------------------- * Look up the state of a feature. */ SQMOD_NODISCARD bool GetFeature(StackStrF & name) const { return getFeature(name.ToStr()); } /* -------------------------------------------------------------------------------------------- * Set the value of a property. */ void SetProperty(const LightObj & value, StackStrF & name); /* -------------------------------------------------------------------------------------------- * Look up the value of a property. */ SQMOD_NODISCARD LightObj GetProperty(StackStrF & name) const; /* -------------------------------------------------------------------------------------------- * Retrieve a statement from this session. */ SQMOD_NODISCARD SqDataStatement GetStatement(StackStrF & data); /* -------------------------------------------------------------------------------------------- * Retrieve a record-set from this session. */ SQMOD_NODISCARD SqDataRecordSet GetRecordSet(StackStrF & data); /* -------------------------------------------------------------------------------------------- * Create a statement and execute the given query immediately. */ SqDataSession & Execute(StackStrF & query); /* -------------------------------------------------------------------------------------------- * Create a statement and execute the given query whenever possible. */ SqDataSession & ExecuteAsync(StackStrF & query); }; /* ------------------------------------------------------------------------------------------------ * Statement is used to execute SQL statements. */ struct SqDataStatementResult : public SqChainedInstances< SqDataStatementResult > { /* -------------------------------------------------------------------------------------------- * Watched result. */ Statement::Result mRes; /* -------------------------------------------------------------------------------------------- * Script callback. */ Function mFunc; /* -------------------------------------------------------------------------------------------- * Reference to the statement. */ LightObj mStmt; /* -------------------------------------------------------------------------------------------- * Reference to self. */ LightObj mSelf; /* -------------------------------------------------------------------------------------------- * Base constructor. */ explicit SqDataStatementResult(const Statement::Result & r, LightObj && stmt) : mRes(r), mFunc(), mStmt(std::move(stmt)), mSelf() { } /* -------------------------------------------------------------------------------------------- * Copy constructor. */ SqDataStatementResult(const SqDataStatementResult &) = delete; /* -------------------------------------------------------------------------------------------- * Move constructor. */ SqDataStatementResult(SqDataStatementResult &&) = delete; /* -------------------------------------------------------------------------------------------- * Destructor. */ ~SqDataStatementResult() { // Forget about this instance UnchainInstance(); } /* -------------------------------------------------------------------------------------------- * Assignment operator. */ SqDataStatementResult & operator = (const SqDataStatementResult &) = delete; /* -------------------------------------------------------------------------------------------- * Move assignment. */ SqDataStatementResult & operator = (SqDataStatementResult &&) = delete; /* -------------------------------------------------------------------------------------------- * Bind a callback and wait for completion. */ LightObj & Bind(Function & fn) { mFunc = std::move(fn); // Reference self to prevent destruction mSelf = LightObj(this); // Remember this instance ChainInstance(); // Return the statement return mStmt; } }; /* ------------------------------------------------------------------------------------------------ * Statement is used to execute SQL statements. */ struct SqDataStatement : public Statement { /* -------------------------------------------------------------------------------------------- * Creates the Statement for the given Session. */ explicit SqDataStatement(SqDataSession & session) : Statement(session) { } /* -------------------------------------------------------------------------------------------- * Creates the Statement for the given Session and adds initial SQL code. */ explicit SqDataStatement(SqDataSession & session, StackStrF & data) : Statement(session) { Add(data); } /* -------------------------------------------------------------------------------------------- * Copy constructor. If the statement has been executed asynchronously and has not been * synchronized prior to copy operation (i.e. is copied while executing), this constructor shall synchronize it. */ SqDataStatement(const SqDataStatement &) = default; /* -------------------------------------------------------------------------------------------- * Move constructor. */ SqDataStatement(SqDataStatement &&) noexcept = default; /* -------------------------------------------------------------------------------------------- * Destroys the Statement. */ ~SqDataStatement() = default; /* -------------------------------------------------------------------------------------------- * Assignment operator. */ SqDataStatement & operator = (const SqDataStatement &) = default; /* -------------------------------------------------------------------------------------------- * Move assignment. */ SqDataStatement & operator = (SqDataStatement &&) noexcept = default; /* -------------------------------------------------------------------------------------------- * Concatenates data with the SQL statement string. */ SqDataStatement & Add(StackStrF & data) { Statement::operator<<(data); // Allow chaining return *this; } /* -------------------------------------------------------------------------------------------- * Returns true if statement was marked for asynchronous execution. */ bool GetAsync() { return isAsync(); } /* -------------------------------------------------------------------------------------------- * Sets the asynchronous flag. This setting does not affect the statement's capability * to be executed synchronously by directly calling Execute(). */ SqDataStatement & SetAsync(bool async) { setAsync(async); return *this; } /* -------------------------------------------------------------------------------------------- * Returns true if the statement was initialized (i.e. not executed yet). */ bool Initialized() { return initialized(); } /* -------------------------------------------------------------------------------------------- * Returns true if the statement was paused (a range limit stopped it and there is more work to do). */ bool Paused() { return paused(); } /* -------------------------------------------------------------------------------------------- * Returns true if the statement was completely executed or false if a range limit stopped it * and there is more work to do. When no limit is set, it will always return true after calling execute(). */ bool Done() { return done(); } /* -------------------------------------------------------------------------------------------- * Returns true if statement is in a state that allows the internal storage to be modified. */ bool CanModifyStorage() { return canModifyStorage(); } /* -------------------------------------------------------------------------------------------- * Returns the internal storage type for the statement. */ SQInteger Storage() const { return static_cast< SQInteger >(storage()); } /* -------------------------------------------------------------------------------------------- * Returns the internal storage type for the statement. */ const std::string & GetStorage() const { return getStorage(); } /* -------------------------------------------------------------------------------------------- * Sets the internal storage type for the statement. */ void SetStorage(StackStrF & storage) { setStorage(storage.ToStr()); } /* -------------------------------------------------------------------------------------------- * Returns the number of columns returned for current data set. * Default value indicates current data set (if any). */ SQInteger GetColumnsExtracted(int data_set) const { return static_cast< SQInteger >(columnsExtracted(data_set)); } SQInteger ColumnsExtracted() const { return static_cast< SQInteger >(columnsExtracted()); } /* -------------------------------------------------------------------------------------------- * Returns the number of rows returned for current data set during last statement execution. * Default value indicates current data set (if any). */ SQInteger GetRowsExtracted(int data_set) const { return static_cast< SQInteger >(rowsExtracted(data_set)); } SQInteger RowsExtracted() const { return static_cast< SQInteger >(rowsExtracted()); } /* -------------------------------------------------------------------------------------------- * Returns the number of rows extracted so far for the data set. * Default value indicates current data set (if any). */ SQInteger GetSubTotalRowCount(int data_set) const { return static_cast< SQInteger >(subTotalRowCount(data_set)); } SQInteger SubTotalRowCount() const { return static_cast< SQInteger >(subTotalRowCount()); } /* -------------------------------------------------------------------------------------------- * Returns the number of extraction storage buffers associated with the current data set. */ SQInteger ExtractionCount() const { return static_cast< SQInteger >(extractionCount()); } /* -------------------------------------------------------------------------------------------- * Returns the number of data sets associated with the statement. */ SQInteger DataSetCount() const { return static_cast< SQInteger >(dataSetCount()); } /* -------------------------------------------------------------------------------------------- * Returns the index of the next data set. */ SQInteger NextDataSet() { return static_cast< SQInteger >(nextDataSet()); } /* -------------------------------------------------------------------------------------------- * Returns the index of the previous data set. */ SQInteger PreviousDataSet() { return static_cast< SQInteger >(previousDataSet()); } /* -------------------------------------------------------------------------------------------- * Returns false if the current data set index points to the last data set. Otherwise, it returns true. */ bool HasMoreDataSets() const { return hasMoreDataSets(); } /* -------------------------------------------------------------------------------------------- * Executes the statement synchronously or asynchronously. */ SQInteger Execute() { return static_cast< SQInteger >(execute(true)); } /* -------------------------------------------------------------------------------------------- * Executes the statement synchronously or asynchronously. */ SQInteger Execute_(bool reset) { return static_cast< SQInteger >(execute(reset)); } /* -------------------------------------------------------------------------------------------- * Executes the statement synchronously or asynchronously. Returns itself instead of rows. */ SqDataStatement & ExecuteChained() { execute(true); // Allow chaining return *this; } /* -------------------------------------------------------------------------------------------- * Executes the statement synchronously or asynchronously. Returns itself instead of rows. */ SqDataStatement & ExecuteChained_(bool reset) { execute(reset); // Allow chaining return *this; } /* -------------------------------------------------------------------------------------------- * Executes the statement asynchronously. */ LightObj ExecuteAsync() { return LightObj(SqTypeIdentity< SqDataStatementResult >{}, SqVM(), executeAsync(true), LightObj(this)); } /* -------------------------------------------------------------------------------------------- * Executes the statement asynchronously. */ LightObj ExecuteAsync_(bool reset) { return LightObj(SqTypeIdentity< SqDataStatementResult >{}, SqVM(), executeAsync(reset), LightObj(this)); } /* -------------------------------------------------------------------------------------------- * Executes the statement asynchronously. */ SqDataStatement & ExecuteAsyncChained() { executeAsync(true); return *this; } /* -------------------------------------------------------------------------------------------- * Executes the statement asynchronously. */ SqDataStatement & ExecuteAsyncChained_(bool reset) { executeAsync(reset); return *this; } /* -------------------------------------------------------------------------------------------- * Waits for the execution completion for asynchronous statements or returns immediately for synchronous ones. */ SQInteger Wait(SQInteger milliseconds) { return static_cast< SQInteger >(wait(static_cast< long >(milliseconds))); } /* -------------------------------------------------------------------------------------------- * Resets the Statement so that it can be filled with a new SQL command. */ SqDataStatement & Reset(SqDataSession & session) { reset(session); return *this; } /* -------------------------------------------------------------------------------------------- * Swaps the statement with another one. */ void Swap(SqDataStatement & stmt) { swap(stmt); } /* -------------------------------------------------------------------------------------------- * Bind a reference to the statement. */ SqDataStatement & Use(LightObj & obj) { UseEx(obj, String(), Poco::Data::AbstractBinding::PD_IN); return *this; } /* -------------------------------------------------------------------------------------------- * Bind a named reference to the statement. */ SqDataStatement & UseAs(LightObj & obj, StackStrF & name) { UseEx(obj, String(name.mPtr, name.GetSize()), Poco::Data::AbstractBinding::PD_IN); return *this; } /* -------------------------------------------------------------------------------------------- * Internal function used internally to bind a reference to the statement. */ void UseEx(LightObj & obj, const std::string & name, Poco::Data::AbstractBinding::Direction dir); /* -------------------------------------------------------------------------------------------- * Internal function used internally to bind a instance reference to the statement. */ void UseInst_(LightObj & obj, const std::string & name, Poco::Data::AbstractBinding::Direction dir); /* -------------------------------------------------------------------------------------------- * Bind a reference to the statement and mark it as input (i.e alias of Use). */ SqDataStatement & In(LightObj & obj) { return Use(obj); } /* -------------------------------------------------------------------------------------------- * Bind a named reference to the statement mark it as input (i.e alias of UseAs). */ SqDataStatement & InAs(LightObj & obj, StackStrF & name) { return UseAs(obj, name); } /* -------------------------------------------------------------------------------------------- * Bind a reference to the statement and mark it as output. */ SqDataStatement & Out(LightObj & obj) { UseEx(obj, String(), Poco::Data::AbstractBinding::PD_OUT); return *this; } /* -------------------------------------------------------------------------------------------- * Bind a named reference to the statement and mark it as output. */ SqDataStatement & OutAs(LightObj & obj, StackStrF & name) { UseEx(obj, String(name.mPtr, name.GetSize()), Poco::Data::AbstractBinding::PD_OUT); return *this; } /* -------------------------------------------------------------------------------------------- * Bind a value to the statement. */ SqDataStatement & Bind(LightObj & obj) { BindEx(obj, String(), Poco::Data::AbstractBinding::PD_IN); return *this; } /* -------------------------------------------------------------------------------------------- * Bind a named value to the statement. */ SqDataStatement & BindAs(LightObj & obj, StackStrF & name) { BindEx(obj, String(name.mPtr, name.GetSize()), Poco::Data::AbstractBinding::PD_IN); return *this; } /* -------------------------------------------------------------------------------------------- * Internal function used internally to bind a value to the statement. */ void BindEx(LightObj & obj, const std::string & name, Poco::Data::AbstractBinding::Direction dir); /* -------------------------------------------------------------------------------------------- * Internal function used internally to bind a instance value to the statement. */ void BindInst_(LightObj & obj, const std::string & name, Poco::Data::AbstractBinding::Direction dir); /* -------------------------------------------------------------------------------------------- * Bind a value/reference to the statement and mark it as input/output. */ SqDataStatement & Io(LightObj & obj) { if (obj.GetType() == OT_INSTANCE) { UseInst_(obj, String(), Poco::Data::AbstractBinding::PD_IN_OUT); } else { Bind(obj); } return *this; } /* -------------------------------------------------------------------------------------------- * Register a single extraction with the statement. */ SqDataStatement & Into(LightObj & obj); /* -------------------------------------------------------------------------------------------- * Register a single extraction with the statement with a default value. */ SqDataStatement & Into_(LightObj & obj, LightObj & def); /* -------------------------------------------------------------------------------------------- * Sets a limit on the maximum number of rows a select is allowed to return. */ SqDataStatement & Limit1(SQInteger limit) { return Limit3(limit, false, false); } SqDataStatement & Limit2(SQInteger limit, bool hard) { return Limit3(limit, hard, false); } SqDataStatement & Limit3(SQInteger limit, bool hard, bool lower) { (*this), Poco::Data::Limit(static_cast< Poco::Data::Limit::SizeT >(limit), hard, lower); return *this; } /* -------------------------------------------------------------------------------------------- * Sets a an extraction range for the maximum number of rows a select is allowed to return. */ SqDataStatement & Range(SQInteger lower, SQInteger upper) { return RangeEx(lower, upper, false); } SqDataStatement & RangeEx(SQInteger lower, SQInteger upper, bool hard) { (*this), Poco::Data::Range(static_cast< Poco::Data::Limit::SizeT >(lower), static_cast< Poco::Data::Limit::SizeT >(upper), hard); return *this; } }; // ------------------------------------------------------------------------------------------------ template < class T > inline SqDataBinding< T > & SqDataBinding< T >::Use(SqDataStatement & stmt) { stmt.addBind(new Poco::Data::ReferenceBinding< T >(mV, String(), Poco::Data::AbstractBinding::PD_IN)); return *this; } // ------------------------------------------------------------------------------------------------ template < class T > inline SqDataBinding< T > & SqDataBinding< T >::UseAs(SqDataStatement & stmt, StackStrF & name) { stmt.addBind(new Poco::Data::ReferenceBinding< T >(mV, name.ToStr(), Poco::Data::AbstractBinding::PD_IN)); return *this; } // ------------------------------------------------------------------------------------------------ template < class T > inline SqDataBinding< T > & SqDataBinding< T >::Bind(SqDataStatement & stmt) { stmt.addBind(new Poco::Data::CopyBinding< T >(*mV, String(), Poco::Data::AbstractBinding::PD_IN)); return *this; } // ------------------------------------------------------------------------------------------------ template < class T > inline SqDataBinding< T > & SqDataBinding< T >::BindAs(SqDataStatement & stmt, StackStrF & name) { stmt.addBind(new Poco::Data::CopyBinding< T >(*mV, name.ToStr(), Poco::Data::AbstractBinding::PD_IN)); return *this; } /* ------------------------------------------------------------------------------------------------ * RecordSet provides access to data returned from a query. */ struct SqDataRecordSet : public RecordSet { /* -------------------------------------------------------------------------------------------- * Creates the RecordSet for the given statement. */ SqDataRecordSet(SqDataStatement & stmt) : RecordSet(stmt) { } /* -------------------------------------------------------------------------------------------- * Creates the RecordSet for the given query. */ SqDataRecordSet(SqDataSession & session, StackStrF & query) : RecordSet(session, query.ToStr()) { } /* -------------------------------------------------------------------------------------------- * Copy constructor. If the statement has been executed asynchronously and has not been * synchronized prior to copy operation (i.e. is copied while executing), this constructor shall synchronize it. */ SqDataRecordSet(const SqDataRecordSet &) = default; /* -------------------------------------------------------------------------------------------- * Move constructor. */ SqDataRecordSet(SqDataRecordSet &&) noexcept = default; /* -------------------------------------------------------------------------------------------- * Destroys the RecordSet. */ ~SqDataRecordSet() = default; /* -------------------------------------------------------------------------------------------- * Assignment operator. */ SqDataRecordSet & operator = (const SqDataRecordSet &) = default; /* -------------------------------------------------------------------------------------------- * Move assignment. */ SqDataRecordSet & operator = (SqDataRecordSet &&) noexcept = default; /* -------------------------------------------------------------------------------------------- * Returns the number of rows in the RecordSet. The number of rows reported is dependent on filtering. */ SQInteger RowCount() const { return static_cast< SQInteger >(rowCount()); } /* -------------------------------------------------------------------------------------------- * Returns the number of rows extracted during the last statement execution. * The number of rows reported is independent of filtering. */ SQInteger ExtractedRowCount() const { return static_cast< SQInteger >(extractedRowCount()); } /* -------------------------------------------------------------------------------------------- * Returns the total number of rows in the RecordSet. * The number of rows reported is independent of filtering. */ SQInteger GetTotalRowCount() const { return static_cast< SQInteger >(getTotalRowCount()); } /* -------------------------------------------------------------------------------------------- * Explicitly sets the total row count. */ void SetTotalRowCount(SQInteger totalRowCount) { setTotalRowCount(ClampL< SQInteger, size_t >(totalRowCount)); } /* -------------------------------------------------------------------------------------------- * Implicitly sets the total row count. The supplied sql must return exactly one column and one row. * The returned value must be an unsigned integer. The value is set as the total number of rows. */ void SetTotalRowCountQ(StackStrF & sql) { setTotalRowCount(sql.ToStr()); } /* -------------------------------------------------------------------------------------------- * Returns the number of columns in the recordset. */ SQInteger ColumnCount() const { return static_cast< SQInteger >(columnCount()); } /* -------------------------------------------------------------------------------------------- * Moves the row cursor to the first row. * Returns true if there is at least one row in the RecordSet, false otherwise. */ bool MoveFirst() { return moveFirst(); } /* -------------------------------------------------------------------------------------------- * Moves the row cursor to the next row. * Returns true if the row is available, or false if the end of the record set has been reached and no more rows are available. */ bool MoveNext() { return moveNext(); } /* -------------------------------------------------------------------------------------------- * Moves the row cursor to the previous row. * Returns true if the row is available, or false if there are no more rows available. */ bool MovePrevious() { return movePrevious(); } /* -------------------------------------------------------------------------------------------- * Moves the row cursor to the last row. * Returns true if there is at least one row in the RecordSet, false otherwise. */ bool MoveLast() { return moveLast(); } /* -------------------------------------------------------------------------------------------- * Resets the RecordSet and assigns a new statement. * Should be called after the given statement has been reset, assigned a new SQL statement, and executed. * Does not remove the associated RowFilter or RowFormatter. */ void Reset(const SqDataStatement & stmt) { reset(stmt); } /* -------------------------------------------------------------------------------------------- * Retrieve the value in the given column (index) of the current row if the value is not NULL. */ LightObj GetValueAt(SQInteger idx) { size_t i = ClampL< SQInteger, size_t >(idx); return GetValueImpl(value(i), columnType(i), LightObj{}); } /* -------------------------------------------------------------------------------------------- * Retrieve the value in the given column (index) of the current row if the value is not NULL, or `fallback` otherwise. */ LightObj GetValueAtOr(SQInteger idx, const LightObj & fallback) { size_t i = ClampL< SQInteger, size_t >(idx); return GetValueImpl(value(i), columnType(i), fallback); } /* -------------------------------------------------------------------------------------------- * Retrieve the value in the given column (name) of the current row if the value is not NULL. */ LightObj GetValue(StackStrF & name) { String s(name.ToStr()); return GetValueImpl(value(s), columnType(s), LightObj{}); } /* -------------------------------------------------------------------------------------------- * Retrieve the value in the given column (name) of the current row if the value is not NULL, or `fallback` otherwise. */ LightObj GetValueOr(StackStrF & name, const LightObj & fallback) { String s(name.ToStr()); return GetValueImpl(value(s), columnType(s), fallback); } /* -------------------------------------------------------------------------------------------- * Retrieve the type for the column at specified position. */ SQInteger ColumnTypeAt(SQInteger pos) const { return static_cast< SQInteger >(columnType(ClampL< SQInteger, size_t >(pos))); } /* -------------------------------------------------------------------------------------------- * Retrieve the type for the column with specified name. */ SQInteger ColumnType(StackStrF & name) const { return static_cast< SQInteger >(columnType(name.ToStr())); } /* -------------------------------------------------------------------------------------------- * Retrieve column name for the column at specified position. */ const std::string & ColumnName(SQInteger pos) const { return columnName(ClampL< SQInteger, size_t >(pos)); } /* -------------------------------------------------------------------------------------------- * Retrieve column maximum length for the column at specified position. */ SQInteger ColumnLengthAt(SQInteger pos) const { return static_cast< SQInteger >(columnLength(ClampL< SQInteger, size_t >(pos))); } /* -------------------------------------------------------------------------------------------- * Retrieve column maximum length for the column with specified name. */ SQInteger ColumnLength(StackStrF & name) const { return static_cast< SQInteger >(columnLength(name.ToStr())); } /* -------------------------------------------------------------------------------------------- * Retrieve column precision for the column at specified position. * Valid for floating point fields only (zero for other data types). */ SQInteger ColumnPrecisionAt(SQInteger pos) const { return static_cast< SQInteger >(columnPrecision(ClampL< SQInteger, size_t >(pos))); } /* -------------------------------------------------------------------------------------------- * Retrieve column precision for the column with specified name. * Valid for floating point fields only (zero for other data types). */ SQInteger ColumnPrecision(StackStrF & name) const { return static_cast< SQInteger >(columnPrecision(name.ToStr())); } /* -------------------------------------------------------------------------------------------- * Returns true if column value of the current row is null. */ bool IsNull(StackStrF & name) const { return isNull(name.ToStr()); } /* -------------------------------------------------------------------------------------------- * Returns true if recordset is filtered. */ bool IsFiltered() const { return isFiltered(); } protected: /* -------------------------------------------------------------------------------------------- * Retrieve the value in the given column (index) of the current row if the value is not NULL, or `fallback` otherwise. */ static LightObj GetValueImpl(const Poco::Dynamic::Var & v, Poco::Data::MetaColumn::ColumnDataType t, const LightObj & fb) { // Is null? if (v.isEmpty()) { return fb; // Use fallback } // Identify type switch (t) { case Poco::Data::MetaColumn::FDT_BOOL: return LightObj(SqInPlace{}, SqVM(), v.convert< bool >()); case Poco::Data::MetaColumn::FDT_INT8: case Poco::Data::MetaColumn::FDT_INT16: case Poco::Data::MetaColumn::FDT_INT32: #ifndef _SQ64 return LightObj(SqInPlace{}, SqVM(), v.convert< SQInteger >()); #endif case Poco::Data::MetaColumn::FDT_INT64: return LightObj(SqInPlace{}, SqVM(), v.convert< int64_t >()); case Poco::Data::MetaColumn::FDT_UINT8: case Poco::Data::MetaColumn::FDT_UINT16: case Poco::Data::MetaColumn::FDT_UINT32: #ifndef _SQ64 return LightObj(SqInPlace{}, SqVM(), v.convert< SQUnsignedInteger >()); #endif case Poco::Data::MetaColumn::FDT_UINT64: return LightObj(SqInPlace{}, SqVM(), v.convert< uint64_t >()); case Poco::Data::MetaColumn::FDT_FLOAT: return LightObj(SqInPlace{}, SqVM(), v.convert< float >()); case Poco::Data::MetaColumn::FDT_DOUBLE: return LightObj(SqInPlace{}, SqVM(), v.convert< double >()); case Poco::Data::MetaColumn::FDT_STRING: case Poco::Data::MetaColumn::FDT_WSTRING: return LightObj(SqInPlace{}, SqVM(), v.convert< std::string >()); case Poco::Data::MetaColumn::FDT_BLOB: { auto & b = v.extract< Poco::Data::BLOB >(); return LightObj(SqTypeIdentity< SqBuffer >{}, SqVM(), reinterpret_cast< Buffer::ConstPtr >(b.rawContent()), static_cast< SQInteger >(b.size())); } case Poco::Data::MetaColumn::FDT_CLOB: { auto & b = v.extract< Poco::Data::CLOB >(); return LightObj(SqTypeIdentity< SqString >{}, SqVM(), SqInPlace{}, b.rawContent(), b.size()); } case Poco::Data::MetaColumn::FDT_DATE: case Poco::Data::MetaColumn::FDT_TIME: case Poco::Data::MetaColumn::FDT_TIMESTAMP: STHROWF("This type of data is currently not implemented."); default: STHROWF("Unknown or unsupported type"); } SQ_UNREACHABLE // Unreachable return LightObj(); } }; /* ------------------------------------------------------------------------------------------------ * SessionPool implements session pooling for POCO Data. */ struct SqDataSessionPool : public SessionPool { /* -------------------------------------------------------------------------------------------- * Creates the SessionPool for sessions with the given connector and connection string. */ SqDataSessionPool(StackStrF & connector, StackStrF & connection) : SessionPool(connector.ToStr(), connection.ToStr()) { } /* -------------------------------------------------------------------------------------------- * Creates the SessionPool for sessions with the given connector and connection string. */ SqDataSessionPool(StackStrF & connector, int min_ses, int max_ses, int idle_time, StackStrF & connection) : SessionPool(connector.ToStr(), connection.ToStr(), min_ses, max_ses, idle_time) { } /* -------------------------------------------------------------------------------------------- * Copy constructor (disabled). */ SqDataSessionPool(const SqDataSessionPool &) = delete; /* -------------------------------------------------------------------------------------------- * Move constructor (disabled). */ SqDataSessionPool(SqDataSessionPool &&) noexcept = delete; /* -------------------------------------------------------------------------------------------- * Destroys the SessionPool. */ ~SqDataSessionPool() = default; /* -------------------------------------------------------------------------------------------- * Assignment operator (disabled). */ SqDataSessionPool & operator = (const SqDataSessionPool &) = delete; /* -------------------------------------------------------------------------------------------- * Move assignment (disabled). */ SqDataSessionPool & operator = (SqDataSessionPool &&) noexcept = delete; /* -------------------------------------------------------------------------------------------- * Retrieve a Session. */ LightObj Get() { return LightObj(SqTypeIdentity< SqDataSession >{}, SqVM(), get()); } /* -------------------------------------------------------------------------------------------- * Retrieve a Session with requested property set. */ LightObj GetWithProperty(const LightObj & value, StackStrF & name) { switch (value.GetType()) { case OT_NULL: { return LightObj(SqTypeIdentity< SqDataSession >{}, SqVM(), get(name.ToStr(), nullptr)); } break; case OT_INTEGER: { return LightObj(SqTypeIdentity< SqDataSession >{}, SqVM(), get(name.ToStr(), value.Cast< SQInteger >())); } break; case OT_FLOAT: { return LightObj(SqTypeIdentity< SqDataSession >{}, SqVM(), get(name.ToStr(), value.Cast< SQFloat >())); } break; case OT_BOOL: { return LightObj(SqTypeIdentity< SqDataSession >{}, SqVM(), get(name.ToStr(), value.Cast< bool >())); } break; case OT_STRING: { return LightObj(SqTypeIdentity< SqDataSession >{}, SqVM(), get(name.ToStr(), value.Cast< std::string >())); } break; default: STHROWF("Unsupported property value type"); } // Should never get here SQ_UNREACHABLE } /* -------------------------------------------------------------------------------------------- * Retrieve a Session with requested feature set. */ LightObj GetWithFeature(bool value, StackStrF & name) { return LightObj(SqTypeIdentity< SqDataSession >{}, SqVM(), get(name.ToStr(), value)); } /* -------------------------------------------------------------------------------------------- * Returns the maximum number of sessions the SessionPool will manage. */ SQInteger GetCapacity() const { return capacity(); } /* -------------------------------------------------------------------------------------------- * Returns the number of sessions currently in use. */ SQInteger GetUsed() const { return used(); } /* -------------------------------------------------------------------------------------------- * Returns the number of idle sessions. */ SQInteger GetIdle() const { return idle(); } /* -------------------------------------------------------------------------------------------- * Returns the number of not connected active sessions. */ SQInteger GetDead() { return dead(); } /* -------------------------------------------------------------------------------------------- * Returns the number of allocated sessions. */ SQInteger GetAllocated() const { return allocated(); } /* -------------------------------------------------------------------------------------------- * Returns the number of available (idle + remaining capacity) sessions. */ SQInteger GetAvailable() const { return available(); } /* -------------------------------------------------------------------------------------------- * Returns the name for this pool. */ String GetName() const { return name(); } /* -------------------------------------------------------------------------------------------- * Returns the name formatted from supplied arguments as "connector:///connection". */ static String GetName_(StackStrF & connector, StackStrF & connection) { return name(connector.ToStr(), connection.ToStr()); } /* -------------------------------------------------------------------------------------------- * Sets feature for all the sessions. */ SqDataSessionPool & SetFeature(StackStrF & name, bool state) { setFeature(name.ToStr(), state); return *this; } /* -------------------------------------------------------------------------------------------- * Returns the requested feature. */ bool GetFeature(StackStrF & name) { return getFeature(name.ToStr()); } /* -------------------------------------------------------------------------------------------- * Sets property for all sessions. */ SqDataSessionPool & SetProperty(const LightObj & value, StackStrF & name) { switch (value.GetType()) { case OT_NULL: { setProperty(name.ToStr(), Poco::Any(nullptr)); } break; case OT_INTEGER: { setProperty(name.ToStr(), Poco::Any(value.Cast< SQInteger >())); } break; case OT_FLOAT: { setProperty(name.ToStr(), Poco::Any(value.Cast< SQFloat >())); } break; case OT_BOOL: { setProperty(name.ToStr(), Poco::Any(value.Cast())); } break; case OT_STRING: { setProperty(name.ToStr(), Poco::Any(value.Cast())); } break; default: STHROWF("Unsupported property value type"); } return *this; } /* -------------------------------------------------------------------------------------------- * Returns the requested property. */ LightObj GetProperty(StackStrF & name); /* -------------------------------------------------------------------------------------------- * Shuts down the session pool. */ void Shutdown() { shutdown(); } /* -------------------------------------------------------------------------------------------- * Returns true if session pool is active (not shut down). */ bool IsActive() const { return isActive(); } }; /* ------------------------------------------------------------------------------------------------ * Helps with transactions in domain logic. */ struct SqDataTransaction : public Transaction { /* -------------------------------------------------------------------------------------------- * Base constructor. */ explicit SqDataTransaction(SqDataSession & session) : Transaction(session) { } /* -------------------------------------------------------------------------------------------- * Base constructor. */ SqDataTransaction(SqDataSession & session, bool start) : Transaction(session, start) { } /* -------------------------------------------------------------------------------------------- * Copy constructor. */ SqDataTransaction(const SqDataTransaction &) = delete; /* -------------------------------------------------------------------------------------------- * Move constructor. */ SqDataTransaction(SqDataTransaction &&) = delete; /* -------------------------------------------------------------------------------------------- * Destructor. */ ~SqDataTransaction() = default; /* -------------------------------------------------------------------------------------------- * Assignment operator. */ SqDataTransaction & operator = (const SqDataTransaction &) = delete; /* -------------------------------------------------------------------------------------------- * Move assignment. */ SqDataTransaction & operator = (SqDataTransaction &&) = delete; /* -------------------------------------------------------------------------------------------- * Returns false after the transaction has been committed or rolled back, * true if the transaction is ongoing. */ SQMOD_NODISCARD bool IsActive() { return Transaction::isActive(); } /* -------------------------------------------------------------------------------------------- * Sets the transaction isolation level. */ void SetIsolation(SQInteger ti) { Transaction::setIsolation(static_cast< Poco::UInt32 >(ti)); } /* -------------------------------------------------------------------------------------------- * Returns the transaction isolation level. */ SQMOD_NODISCARD SQInteger GetIsolation() { return static_cast< SQInteger >(Transaction::getIsolation()); } /* -------------------------------------------------------------------------------------------- * Returns true iff the transaction isolation level corresponding to the supplied bitmask is supported. */ SQMOD_NODISCARD bool HasIsolation(SQInteger ti) { return Transaction::hasIsolation(static_cast< Poco::UInt32 >(ti)); } /* -------------------------------------------------------------------------------------------- * Returns true iff the transaction isolation level corresponds to the supplied bitmask. */ SQMOD_NODISCARD bool IsIsolation(SQInteger ti) { return Transaction::isIsolation(static_cast< Poco::UInt32 >(ti)); } /* -------------------------------------------------------------------------------------------- * Executes and, if do_commit is true, commits the transaction. * Passing true value for commit disables rollback during destruction of this Transaction object. */ SqDataTransaction & Execute(bool do_commit, StackStrF & sql) { Transaction::execute(sql.ToStr(), do_commit); return *this; } /* -------------------------------------------------------------------------------------------- * Executes all the SQL statements supplied in the vector and, * after the last one is sucesfully executed, commits the transaction. */ SqDataTransaction & ExecuteList(const SqVector< std::string > & sql) { Transaction::execute(sql.Valid()); return *this; } /* -------------------------------------------------------------------------------------------- * Executes the transactor and, unless transactor throws an exception, commits the transaction. */ SqDataTransaction & Transact(Function & cb) { auto t = [&](Session & s) { cb(LightObj(reinterpret_cast< SqDataSession * >(&s), nullptr)); }; Transaction::transact(t); return *this; } /* -------------------------------------------------------------------------------------------- * Commits the current transaction. */ SqDataTransaction & Commit() { Transaction::commit(); return *this; } /* -------------------------------------------------------------------------------------------- * Rolls back the current transaction. */ SqDataTransaction & Rollback() { Transaction::rollback(); return *this; } }; } // Namespace:: SqMod