Statement.h

/*
 * MIT License
 *
 * Copyright (c) 2025 Adriano dos Santos Fernandes
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#ifndef FBCPP_STATEMENT_H
#define FBCPP_STATEMENT_H
 
#include "config.h"
#include "fb-cpp-export.h"
#include "fb-api.h"
#include "types.h"
#include "Blob.h"
#include "Array.h"
#include "Client.h"
#include "Row.h"
#include "StatementOptions.h"
#include "NumericConverter.h"
#include "CalendarConverter.h"
#include "Descriptor.h"
#include "impl/ParameterSetter.h"
#include "SmartPtrs.h"
#include "Exception.h"
#include "StructBinding.h"
#include "VariantTypeTraits.h"
#include <charconv>
#include <cerrno>
#include <cstdlib>
#include <limits>
#include <memory>
#include <optional>
#include <stdexcept>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstdint>
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
 
#if FB_CPP_USE_BOOST_DECIMAL != 0
#include <boost/decimal.hpp>
#endif
 
namespace fbcpp
{
    class Attachment;
    class Transaction;
 
    enum class StatementType : unsigned
    {
        SELECT = isc_info_sql_stmt_select,
        INSERT = isc_info_sql_stmt_insert,
        UPDATE = isc_info_sql_stmt_update,
        DELETE = isc_info_sql_stmt_delete,
        DDL = isc_info_sql_stmt_ddl,
        GET_SEGMENT = isc_info_sql_stmt_get_segment,
        PUT_SEGMENT = isc_info_sql_stmt_put_segment,
        EXEC_PROCEDURE = isc_info_sql_stmt_exec_procedure,
        START_TRANSACTION = isc_info_sql_stmt_start_trans,
        COMMIT = isc_info_sql_stmt_commit,
        ROLLBACK = isc_info_sql_stmt_rollback,
        SELECT_FOR_UPDATE = isc_info_sql_stmt_select_for_upd,
        SET_GENERATOR = isc_info_sql_stmt_set_generator,
        SAVEPOINT = isc_info_sql_stmt_savepoint,
    };
 
    class FB_CPP_EXPORT Statement final : private impl::ParameterSetter<Statement, false>
    {
        friend class RowSet;
        friend class impl::ParameterSetter<Statement, false>;
 
    public:
        explicit Statement(Attachment& attachment, Transaction& transaction, std::string_view sql,
            const StatementOptions& options = {});
 
        Statement(Statement&& o) noexcept;
 
        Statement& operator=(Statement&& o) noexcept;
 
        Statement(const Statement&) = delete;
        Statement& operator=(const Statement&) = delete;
 
        ~Statement() noexcept
        {
            if (isValid())
            {
                try
                {
                    free();
                }
                catch (...)
                {
                    // swallow
                }
            }
        }
 
    public:
 
        Attachment& getAttachment() noexcept
        {
            return *attachment;
        }
 
        bool isValid() noexcept
        {
            return statementHandle != nullptr;
        }
 
        bool hasCurrentRow() const noexcept
        {
            return currentRow;
        }
 
        FbRef<fb::IStatement> getStatementHandle() noexcept
        {
            return statementHandle;
        }
 
        FbRef<fb::IResultSet> getResultSetHandle() noexcept
        {
            return resultSetHandle;
        }
 
        FbRef<fb::IMessageMetadata> getInputMetadata() noexcept
        {
            return inMetadata;
        }
 
        std::vector<std::byte>& getInputMessage() noexcept
        {
            return inMessage;
        }
 
        FbRef<fb::IMessageMetadata> getOutputMetadata() noexcept
        {
            return outMetadata;
        }
 
        std::vector<std::byte>& getOutputMessage() noexcept
        {
            return outMessage;
        }
 
        StatementType getType() noexcept
        {
            return type;
        }
 
 
 
        const std::vector<Descriptor>& getInputDescriptors() noexcept
        {
            return inDescriptors;
        }
 
        const std::vector<Descriptor>& getOutputDescriptors() noexcept
        {
            return outDescriptors;
        }
 
 
        void free();
 
        std::string getLegacyPlan();
 
        std::string getPlan();
 
        bool execute(Transaction& transaction);
 
 
        bool fetchNext();
 
        bool fetchPrior();
 
        bool fetchFirst();
 
        bool fetchLast();
 
        bool fetchAbsolute(unsigned position);
 
        bool fetchRelative(int offset);
 
 
        using impl::ParameterSetter<Statement, false>::clearParameters;
        using impl::ParameterSetter<Statement, false>::set;
        using impl::ParameterSetter<Statement, false>::setBlobId;
        using impl::ParameterSetter<Statement, false>::setArrayId;
        using impl::ParameterSetter<Statement, false>::setBool;
        using impl::ParameterSetter<Statement, false>::setBytes;
        using impl::ParameterSetter<Statement, false>::setDate;
        using impl::ParameterSetter<Statement, false>::setDouble;
        using impl::ParameterSetter<Statement, false>::setFloat;
        using impl::ParameterSetter<Statement, false>::setInt16;
        using impl::ParameterSetter<Statement, false>::setInt32;
        using impl::ParameterSetter<Statement, false>::setInt64;
        using impl::ParameterSetter<Statement, false>::setNull;
        using impl::ParameterSetter<Statement, false>::setOpaqueDate;
        using impl::ParameterSetter<Statement, false>::setOpaqueDecFloat16;
        using impl::ParameterSetter<Statement, false>::setOpaqueDecFloat34;
        using impl::ParameterSetter<Statement, false>::setOpaqueInt128;
        using impl::ParameterSetter<Statement, false>::setOpaqueTime;
        using impl::ParameterSetter<Statement, false>::setOpaqueTimeTz;
        using impl::ParameterSetter<Statement, false>::setOpaqueTimestamp;
        using impl::ParameterSetter<Statement, false>::setOpaqueTimestampTz;
        using impl::ParameterSetter<Statement, false>::setScaledInt16;
        using impl::ParameterSetter<Statement, false>::setScaledInt32;
        using impl::ParameterSetter<Statement, false>::setScaledInt64;
        using impl::ParameterSetter<Statement, false>::setScaledOpaqueInt128;
        using impl::ParameterSetter<Statement, false>::setString;
        using impl::ParameterSetter<Statement, false>::setTime;
        using impl::ParameterSetter<Statement, false>::setTimeTz;
        using impl::ParameterSetter<Statement, false>::setTimestamp;
        using impl::ParameterSetter<Statement, false>::setTimestampTz;
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
        using impl::ParameterSetter<Statement, false>::setBoostDecFloat16;
        using impl::ParameterSetter<Statement, false>::setBoostDecFloat34;
        using impl::ParameterSetter<Statement, false>::setBoostInt128;
        using impl::ParameterSetter<Statement, false>::setScaledBoostInt128;
#endif
 
#if FB_CPP_USE_BOOST_DECIMAL != 0
        using impl::ParameterSetter<Statement, false>::setBoostDecimal128;
        using impl::ParameterSetter<Statement, false>::setBoostDecimal32;
        using impl::ParameterSetter<Statement, false>::setBoostDecimal64;
#endif
 
 
 
        bool isNull(unsigned index)
        {
            assert(isValid());
            return outRow->isNull(index);
        }
 
        std::optional<bool> getBool(unsigned index)
        {
            assert(isValid());
            return outRow->getBool(index);
        }
 
        std::optional<std::int16_t> getInt16(unsigned index)
        {
            assert(isValid());
            return outRow->getInt16(index);
        }
 
        std::optional<ScaledInt16> getScaledInt16(unsigned index)
        {
            assert(isValid());
            return outRow->getScaledInt16(index);
        }
 
        std::optional<std::int32_t> getInt32(unsigned index)
        {
            assert(isValid());
            return outRow->getInt32(index);
        }
 
        std::optional<ScaledInt32> getScaledInt32(unsigned index)
        {
            assert(isValid());
            return outRow->getScaledInt32(index);
        }
 
        std::optional<std::int64_t> getInt64(unsigned index)
        {
            assert(isValid());
            return outRow->getInt64(index);
        }
 
        std::optional<ScaledInt64> getScaledInt64(unsigned index)
        {
            assert(isValid());
            return outRow->getScaledInt64(index);
        }
 
        std::optional<ScaledOpaqueInt128> getScaledOpaqueInt128(unsigned index)
        {
            assert(isValid());
            return outRow->getScaledOpaqueInt128(index);
        }
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
        std::optional<BoostInt128> getBoostInt128(unsigned index)
        {
            assert(isValid());
            return outRow->getBoostInt128(index);
        }
 
        std::optional<ScaledBoostInt128> getScaledBoostInt128(unsigned index)
        {
            assert(isValid());
            return outRow->getScaledBoostInt128(index);
        }
#endif
 
        std::optional<float> getFloat(unsigned index)
        {
            assert(isValid());
            return outRow->getFloat(index);
        }
 
        std::optional<double> getDouble(unsigned index)
        {
            assert(isValid());
            return outRow->getDouble(index);
        }
 
        std::optional<OpaqueDecFloat16> getOpaqueDecFloat16(unsigned index)
        {
            assert(isValid());
            return outRow->getOpaqueDecFloat16(index);
        }
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
        std::optional<BoostDecFloat16> getBoostDecFloat16(unsigned index)
        {
            assert(isValid());
            return outRow->getBoostDecFloat16(index);
        }
#endif
 
#if FB_CPP_USE_BOOST_DECIMAL != 0
        std::optional<BoostDecimal32> getBoostDecimal32(unsigned index)
        {
            assert(isValid());
            return outRow->getBoostDecimal32(index);
        }
 
        std::optional<BoostDecimal64> getBoostDecimal64(unsigned index)
        {
            assert(isValid());
            return outRow->getBoostDecimal64(index);
        }
#endif
 
        std::optional<OpaqueDecFloat34> getOpaqueDecFloat34(unsigned index)
        {
            assert(isValid());
            return outRow->getOpaqueDecFloat34(index);
        }
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
        std::optional<BoostDecFloat34> getBoostDecFloat34(unsigned index)
        {
            assert(isValid());
            return outRow->getBoostDecFloat34(index);
        }
#endif
 
#if FB_CPP_USE_BOOST_DECIMAL != 0
        std::optional<BoostDecimal128> getBoostDecimal128(unsigned index)
        {
            assert(isValid());
            return outRow->getBoostDecimal128(index);
        }
#endif
 
        std::optional<Date> getDate(unsigned index)
        {
            assert(isValid());
            return outRow->getDate(index);
        }
 
        std::optional<OpaqueDate> getOpaqueDate(unsigned index)
        {
            assert(isValid());
            return outRow->getOpaqueDate(index);
        }
 
        std::optional<Time> getTime(unsigned index)
        {
            assert(isValid());
            return outRow->getTime(index);
        }
 
        std::optional<OpaqueTime> getOpaqueTime(unsigned index)
        {
            assert(isValid());
            return outRow->getOpaqueTime(index);
        }
 
        std::optional<Timestamp> getTimestamp(unsigned index)
        {
            assert(isValid());
            return outRow->getTimestamp(index);
        }
 
        std::optional<OpaqueTimestamp> getOpaqueTimestamp(unsigned index)
        {
            assert(isValid());
            return outRow->getOpaqueTimestamp(index);
        }
 
        std::optional<TimeTz> getTimeTz(unsigned index)
        {
            assert(isValid());
            return outRow->getTimeTz(index);
        }
 
        std::optional<OpaqueTimeTz> getOpaqueTimeTz(unsigned index)
        {
            assert(isValid());
            return outRow->getOpaqueTimeTz(index);
        }
 
        std::optional<TimestampTz> getTimestampTz(unsigned index)
        {
            assert(isValid());
            return outRow->getTimestampTz(index);
        }
 
        std::optional<OpaqueTimestampTz> getOpaqueTimestampTz(unsigned index)
        {
            assert(isValid());
            return outRow->getOpaqueTimestampTz(index);
        }
 
        std::optional<BlobId> getBlobId(unsigned index)
        {
            assert(isValid());
            return outRow->getBlobId(index);
        }
 
        std::optional<ArrayId> getArrayId(unsigned index)
        {
            assert(isValid());
            return outRow->getArrayId(index);
        }
 
        std::optional<std::string> getString(unsigned index)
        {
            assert(isValid());
            return outRow->getString(index);
        }
 
        std::optional<std::vector<std::byte>> getBytes(unsigned index)
        {
            assert(isValid());
            return outRow->getBytes(index);
        }
 
 
        template <typename T>
        T get(unsigned index)
        {
            assert(isValid());
            return outRow->get<T>(index);
        }
 
        template <Aggregate T>
        T get()
        {
            assert(isValid());
            return outRow->get<T>();
        }
 
        template <TupleLike T>
        T get()
        {
            assert(isValid());
            return outRow->get<T>();
        }
 
        template <VariantLike V>
        V get(unsigned index)
        {
            assert(isValid());
            return outRow->get<V>(index);
        }
 
    private:
        const std::vector<Descriptor>& getSetterDescriptors() const noexcept
        {
            return inDescriptors;
        }
 
        std::vector<std::byte>& getSetterMessage() noexcept
        {
            return inMessage;
        }
 
        Client& getSetterClient() noexcept
        {
            return getClient();
        }
 
        void validateSetter() const noexcept
        {
            assert(statementHandle != nullptr);
        }
 
        Client& getClient() noexcept;
 
        void clearCurrentRow() noexcept
        {
            currentRow = false;
        }
 
    private:
        Attachment* attachment;
        impl::StatusWrapper statusWrapper;
        impl::CalendarConverter calendarConverter;
        impl::NumericConverter numericConverter;
        FbRef<fb::IStatement> statementHandle;
        FbRef<fb::IResultSet> resultSetHandle;
        FbRef<fb::IMessageMetadata> inMetadata;
        std::vector<Descriptor> inDescriptors;
        std::vector<std::byte> inMessage;
        FbRef<fb::IMessageMetadata> outMetadata;
        std::vector<Descriptor> outDescriptors;
        std::vector<std::byte> outMessage;
        std::unique_ptr<Row> outRow;
        StatementType type;
        unsigned cursorFlags = 0;
        bool currentRow = false;
    };
 
 
    template <>
    inline std::optional<bool> Statement::get<std::optional<bool>>(unsigned index)
    {
        return getBool(index);
    }
 
    template <>
    inline std::optional<BlobId> Statement::get<std::optional<BlobId>>(unsigned index)
    {
        return getBlobId(index);
    }
 
    template <>
    inline std::optional<ArrayId> Statement::get<std::optional<ArrayId>>(unsigned index)
    {
        return getArrayId(index);
    }
 
    template <>
    inline std::optional<std::int16_t> Statement::get<std::optional<std::int16_t>>(unsigned index)
    {
        return getInt16(index);
    }
 
    template <>
    inline std::optional<ScaledInt16> Statement::get<std::optional<ScaledInt16>>(unsigned index)
    {
        return getScaledInt16(index);
    }
 
    template <>
    inline std::optional<std::int32_t> Statement::get<std::optional<std::int32_t>>(unsigned index)
    {
        return getInt32(index);
    }
 
    template <>
    inline std::optional<ScaledInt32> Statement::get<std::optional<ScaledInt32>>(unsigned index)
    {
        return getScaledInt32(index);
    }
 
    template <>
    inline std::optional<std::int64_t> Statement::get<std::optional<std::int64_t>>(unsigned index)
    {
        return getInt64(index);
    }
 
    template <>
    inline std::optional<ScaledInt64> Statement::get<std::optional<ScaledInt64>>(unsigned index)
    {
        return getScaledInt64(index);
    }
 
    template <>
    inline std::optional<ScaledOpaqueInt128> Statement::get<std::optional<ScaledOpaqueInt128>>(unsigned index)
    {
        return getScaledOpaqueInt128(index);
    }
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
    template <>
    inline std::optional<BoostInt128> Statement::get<std::optional<BoostInt128>>(unsigned index)
    {
        return getBoostInt128(index);
    }
 
    template <>
    inline std::optional<ScaledBoostInt128> Statement::get<std::optional<ScaledBoostInt128>>(unsigned index)
    {
        return getScaledBoostInt128(index);
    }
#endif
 
    template <>
    inline std::optional<float> Statement::get<std::optional<float>>(unsigned index)
    {
        return getFloat(index);
    }
 
    template <>
    inline std::optional<double> Statement::get<std::optional<double>>(unsigned index)
    {
        return getDouble(index);
    }
 
    template <>
    inline std::optional<OpaqueDecFloat16> Statement::get<std::optional<OpaqueDecFloat16>>(unsigned index)
    {
        return getOpaqueDecFloat16(index);
    }
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
    template <>
    inline std::optional<BoostDecFloat16> Statement::get<std::optional<BoostDecFloat16>>(unsigned index)
    {
        return getBoostDecFloat16(index);
    }
#endif
 
#if FB_CPP_USE_BOOST_DECIMAL != 0
    template <>
    inline std::optional<BoostDecimal32> Statement::get<std::optional<BoostDecimal32>>(unsigned index)
    {
        return getBoostDecimal32(index);
    }
 
    template <>
    inline std::optional<BoostDecimal64> Statement::get<std::optional<BoostDecimal64>>(unsigned index)
    {
        return getBoostDecimal64(index);
    }
#endif
 
    template <>
    inline std::optional<OpaqueDecFloat34> Statement::get<std::optional<OpaqueDecFloat34>>(unsigned index)
    {
        return getOpaqueDecFloat34(index);
    }
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
    template <>
    inline std::optional<BoostDecFloat34> Statement::get<std::optional<BoostDecFloat34>>(unsigned index)
    {
        return getBoostDecFloat34(index);
    }
#endif
 
#if FB_CPP_USE_BOOST_DECIMAL != 0
    template <>
    inline std::optional<BoostDecimal128> Statement::get<std::optional<BoostDecimal128>>(unsigned index)
    {
        return getBoostDecimal128(index);
    }
#endif
 
    template <>
    inline std::optional<Date> Statement::get<std::optional<Date>>(unsigned index)
    {
        return getDate(index);
    }
 
    template <>
    inline std::optional<OpaqueDate> Statement::get<std::optional<OpaqueDate>>(unsigned index)
    {
        return getOpaqueDate(index);
    }
 
    template <>
    inline std::optional<Time> Statement::get<std::optional<Time>>(unsigned index)
    {
        return getTime(index);
    }
 
    template <>
    inline std::optional<OpaqueTime> Statement::get<std::optional<OpaqueTime>>(unsigned index)
    {
        return getOpaqueTime(index);
    }
 
    template <>
    inline std::optional<OpaqueTimestamp> Statement::get<std::optional<OpaqueTimestamp>>(unsigned index)
    {
        return getOpaqueTimestamp(index);
    }
 
    template <>
    inline std::optional<Timestamp> Statement::get<std::optional<Timestamp>>(unsigned index)
    {
        return getTimestamp(index);
    }
 
    template <>
    inline std::optional<TimeTz> Statement::get<std::optional<TimeTz>>(unsigned index)
    {
        return getTimeTz(index);
    }
 
    template <>
    inline std::optional<OpaqueTimeTz> Statement::get<std::optional<OpaqueTimeTz>>(unsigned index)
    {
        return getOpaqueTimeTz(index);
    }
 
    template <>
    inline std::optional<TimestampTz> Statement::get<std::optional<TimestampTz>>(unsigned index)
    {
        return getTimestampTz(index);
    }
 
    template <>
    inline std::optional<OpaqueTimestampTz> Statement::get<std::optional<OpaqueTimestampTz>>(unsigned index)
    {
        return getOpaqueTimestampTz(index);
    }
 
    template <>
    inline std::optional<std::string> Statement::get<std::optional<std::string>>(unsigned index)
    {
        return getString(index);
    }
 
    template <>
    inline std::optional<std::vector<std::byte>> Statement::get<std::optional<std::vector<std::byte>>>(unsigned index)
    {
        return getBytes(index);
    }
 
}  // namespace fbcpp
 
 
#endif  // FBCPP_STATEMENT_H