BasicStringBinder.hpp

// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#include "Core.hpp"
#include "UnicodeConverter.hpp"
 
#include <cassert>
#include <memory>
#include <utility>
 
namespace Lightweight
{
 
/// @brief Magic number, which is used to determine the optimal maximum size of a column.
///
/// Columns may be larger than this value, but this is the optimal maximum size for performance,
/// and usually also means that values are stored in the same row as the rest of the data, or not.
constexpr std::size_t SqlOptimalMaxColumnSize = 4000;
 
namespace detail
{
    /// Helper function to get raw column data of an array-like type.
    ///
    /// @param stmt The SQL statement handle.
    /// @param column The column number to retrieve data from.
    /// @param result The array-like type to store the data in.
    /// @param indicator The indicator to store the length of the data.
    ///
    /// @return SQLRETURN indicating the result of the operation.
    template <auto CType, typename ArrayType>
        requires requires(ArrayType& arr) {
            { arr.data() } -> std::convertible_to<typename ArrayType::value_type*>;
            { arr.size() } -> std::convertible_to<std::size_t>;
            { arr.resize(std::declval<std::size_t>()) };
        }
    static SQLRETURN GetRawColumnArrayData(SQLHSTMT stmt, SQLUSMALLINT column, ArrayType* result, SQLLEN* indicator) noexcept
    {
        using CharType = typename ArrayType::value_type;
 
        *indicator = 0;
 
        // Resize the string to the size of the data
        // Get the data (take care of SQL_NULL_DATA and SQL_NO_TOTAL)
        auto sqlResult = SQLGetData(stmt,
                                    column,
                                    CType,
                                    static_cast<SQLPOINTER>(result->data()),
                                    static_cast<SQLLEN>(result->size() * sizeof(CharType)),
                                    indicator);
 
        if (sqlResult == SQL_SUCCESS || sqlResult == SQL_NO_DATA)
        {
            // Data has been read successfully on first call to SQLGetData, or there is no data to read.
            if (*indicator == SQL_NULL_DATA)
                result->clear();
            else
                result->resize(*indicator / sizeof(CharType));
            return sqlResult;
        }
 
        if (sqlResult == SQL_SUCCESS_WITH_INFO && *indicator > static_cast<SQLLEN>(result->size()))
        {
            // We have a truncation and the server knows how much data is left.
            auto const totalCharCount = *indicator / sizeof(CharType);
            auto const charsWritten = result->size() - 1;
            result->resize(totalCharCount + 1);
            auto* bufferCont = result->data() + charsWritten;
            auto const bufferCharsAvailable = (totalCharCount + 1) - charsWritten;
            sqlResult = SQLGetData(stmt, column, CType, bufferCont, bufferCharsAvailable * sizeof(CharType), indicator);
            if (SQL_SUCCEEDED(sqlResult))
                result->resize(charsWritten + (*indicator / sizeof(CharType)));
            return sqlResult;
        }
 
        size_t writeIndex = 0;
        while (sqlResult == SQL_SUCCESS_WITH_INFO && *indicator == SQL_NO_TOTAL)
        {
            // We have a truncation and the server does not know how much data is left.
            writeIndex += result->size() - 1;
            result->resize(result->size() * 2);
            auto* const bufferStart = result->data() + writeIndex;
            size_t const bufferCharsAvailable = result->size() - writeIndex;
            sqlResult = SQLGetData(stmt, column, CType, bufferStart, bufferCharsAvailable, indicator);
        }
        return sqlResult;
    }
 
    template <typename Utf16StringType>
    SQLRETURN GetColumnUtf16(SQLHSTMT stmt,
                             SQLUSMALLINT column,
                             Utf16StringType* result,
                             SQLLEN* indicator,
                             SqlDataBinderCallback const& /*cb*/) noexcept
    {
        if constexpr (requires { Utf16StringType::Capacity; })
            result->resize(Utf16StringType::Capacity);
        else if (result->size() == 0)
            result->resize(255);
 
        return GetRawColumnArrayData<SQL_C_WCHAR>(stmt, column, result, indicator);
    }
 
    template <typename StringType>
    SQLRETURN BindOutputColumnNonUtf16Unicode(
        SQLHSTMT stmt, SQLUSMALLINT column, StringType* result, SQLLEN* indicator, SqlDataBinderCallback& cb) noexcept
    {
        using CharType = typename StringType::value_type;
 
        auto u16String = std::make_shared<std::u16string>();
        if (!result->empty())
            u16String->resize(result->size());
        else
            u16String->resize(255);
 
        cb.PlanPostProcessOutputColumn([stmt, column, result, indicator, u16String = u16String]() {
            if (*indicator == SQL_NULL_DATA)
                u16String->clear();
            else if (*indicator == SQL_NO_TOTAL)
                ; // We don't know the size of the data
            else if (std::cmp_less_equal(*indicator, u16String->size() * sizeof(char16_t)))
                u16String->resize(*indicator / sizeof(char16_t));
            else
            {
                auto const totalCharsRequired = static_cast<SQLLEN>(*indicator / sizeof(char16_t));
                *indicator += sizeof(char16_t); // Add space to hold the null terminator
                u16String->resize(totalCharsRequired);
                auto const sqlResult = SQLGetData(stmt, column, SQL_C_WCHAR, u16String->data(), *indicator, indicator);
                (void) sqlResult;
                assert(SQL_SUCCEEDED(sqlResult));
                assert(std::cmp_equal(*indicator, totalCharsRequired * sizeof(char16_t)));
            }
 
            if constexpr (sizeof(typename StringType::value_type) == 1)
                *result = ToUtf8(*u16String);
            else if constexpr (sizeof(typename StringType::value_type) == 4)
            {
                // *result = ToUtf32(*u16String);
                auto const u32String = ToUtf32(*u16String);
                *result = StringType {
                    (CharType const*) u32String.data(),
                    (CharType const*) u32String.data() + u32String.size(),
                };
            }
        });
 
        return SQLBindCol(stmt,
                          column,
                          SQL_C_WCHAR,
                          static_cast<SQLPOINTER>(u16String->data()),
                          static_cast<SQLLEN>(u16String->size() * sizeof(char16_t)),
                          indicator);
    }
 
} // namespace detail
 
// SqlDataBinder<> specialization for ANSI character strings
template <typename AnsiStringType>
    requires SqlBasicStringBinderConcept<AnsiStringType, char>
struct SqlDataBinder<AnsiStringType>
{
    using ValueType = AnsiStringType;
    using CharType = char;
    using StringTraits = SqlBasicStringOperations<AnsiStringType>;
 
    static constexpr auto ColumnType = StringTraits::ColumnType;
 
    static LIGHTWEIGHT_FORCE_INLINE SQLRETURN InputParameter(SQLHSTMT stmt,
                                                             SQLUSMALLINT column,
                                                             AnsiStringType const& value,
                                                             SqlDataBinderCallback& /*cb*/) noexcept
    {
        auto const charCount = StringTraits::Size(&value);
        auto const sqlType = static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_LONGVARCHAR : SQL_VARCHAR);
        return SQLBindParameter(stmt,
                                column,
                                SQL_PARAM_INPUT,
                                SQL_C_CHAR,
                                sqlType,
                                charCount,
                                0,
                                (SQLPOINTER) StringTraits::Data(&value),
                                sizeof(AnsiStringType),
                                nullptr);
    }
 
    static LIGHTWEIGHT_FORCE_INLINE SQLRETURN OutputColumn(
        SQLHSTMT stmt, SQLUSMALLINT column, AnsiStringType* result, SQLLEN* indicator, SqlDataBinderCallback& cb) noexcept
    {
        if constexpr (requires { AnsiStringType::Capacity; })
            StringTraits::Resize(result, AnsiStringType::Capacity);
        else if (StringTraits::Size(result) == 0)
            StringTraits::Resize(result, 255);
 
        if constexpr (requires { StringTraits::PostProcessOutputColumn(result, *indicator); })
            cb.PlanPostProcessOutputColumn(
                [indicator, result]() { StringTraits::PostProcessOutputColumn(result, *indicator); });
        else
            cb.PlanPostProcessOutputColumn(
                [stmt, column, indicator, result]() { PostProcessOutputColumn(stmt, column, result, indicator); });
 
        return SQLBindCol(stmt,
                          column,
                          SQL_C_CHAR,
                          (SQLPOINTER) StringTraits::Data(result),
                          (SQLLEN) StringTraits::Size(result),
                          indicator);
    }
 
    static void PostProcessOutputColumn(SQLHSTMT stmt, SQLUSMALLINT column, AnsiStringType* result, SQLLEN* indicator)
    {
        // Now resize the string to the actual length of the data
        // NB: If the indicator is greater than the buffer size, we have a truncation.
        if (*indicator == SQL_NO_TOTAL)
        {
            // We have a truncation and the server does not know how much data is left.
            StringTraits::Resize(result, StringTraits::Size(result) - 1);
        }
        else if (*indicator == SQL_NULL_DATA)
        {
            // We have a NULL value
            StringTraits::Resize(result, 0);
        }
        else if (*indicator <= static_cast<SQLLEN>(StringTraits::Size(result)))
        {
            StringTraits::Resize(result, static_cast<size_t>(*indicator));
        }
        else
        {
            // We have a truncation and the server knows how much data is left.
            // Extend the buffer and fetch the rest via SQLGetData.
 
            auto const totalCharsRequired = *indicator;
            StringTraits::Resize(result, totalCharsRequired + 1);
            auto const sqlResult =
                SQLGetData(stmt, column, SQL_C_CHAR, StringTraits::Data(result), totalCharsRequired + 1, indicator);
            (void) sqlResult;
            assert(SQL_SUCCEEDED(sqlResult));
            assert(*indicator == totalCharsRequired);
            StringTraits::Resize(result, totalCharsRequired);
        }
    }
 
    // NOLINTNEXTLINE(readability-function-cognitive-complexity)
    static SQLRETURN GetColumn(SQLHSTMT stmt,
                               SQLUSMALLINT column,
                               AnsiStringType* result,
                               SQLLEN* indicator,
                               SqlDataBinderCallback const& /*cb*/) noexcept
    {
        if constexpr (requires { AnsiStringType::Capacity; })
        {
            StringTraits::Resize(result, AnsiStringType::Capacity);
            SQLRETURN const rv =
                SQLGetData(stmt, column, SQL_C_CHAR, StringTraits::Data(result), AnsiStringType::Capacity, indicator);
            if (rv == SQL_SUCCESS || rv == SQL_NO_DATA)
            {
                if (*indicator == SQL_NULL_DATA)
                    StringTraits::Resize(result, 0);
                else if (*indicator != SQL_NO_TOTAL)
                    StringTraits::Resize(result, (std::min) (AnsiStringType::Capacity, static_cast<size_t>(*indicator)));
            }
            if constexpr (requires { StringTraits::PostProcessOutputColumn(result, *indicator); })
                StringTraits::PostProcessOutputColumn(result, *indicator);
            return rv;
        }
        else
        {
            StringTraits::Reserve(result, 15);
            size_t writeIndex = 0;
            *indicator = 0;
            while (true)
            {
                auto* const bufferStart = StringTraits::Data(result) + writeIndex;
                size_t const bufferSize = StringTraits::Size(result) - writeIndex;
                SQLRETURN const rv = SQLGetData(stmt, column, SQL_C_CHAR, bufferStart, bufferSize, indicator);
                switch (rv)
                {
                    case SQL_SUCCESS:
                    case SQL_NO_DATA:
                        // last successive call
                        if (*indicator != SQL_NULL_DATA)
                        {
                            StringTraits::Resize(result, writeIndex + *indicator);
                            *indicator = StringTraits::Size(result);
                        }
                        return SQL_SUCCESS;
                    case SQL_SUCCESS_WITH_INFO: {
                        // more data pending
                        if (*indicator == SQL_NO_TOTAL)
                        {
                            // We have a truncation and the server does not know how much data is left.
                            writeIndex += bufferSize - 1;
                            StringTraits::Resize(result, (2 * writeIndex) + 1);
                        }
                        else if (std::cmp_greater_equal(*indicator, bufferSize))
                        {
                            // We have a truncation and the server knows how much data is left.
                            writeIndex += bufferSize - 1;
                            StringTraits::Resize(result, writeIndex + *indicator);
                        }
                        else
                        {
                            // We have no truncation and the server knows how much data is left.
                            StringTraits::Resize(result, writeIndex + *indicator - 1);
                            return SQL_SUCCESS;
                        }
                        break;
                    }
                    default:
                        if constexpr (requires { StringTraits::PostProcessOutputColumn(result, *indicator); })
                            StringTraits::PostProcessOutputColumn(result, *indicator);
                        return rv;
                }
            }
        }
    }
 
    static LIGHTWEIGHT_FORCE_INLINE std::string_view Inspect(AnsiStringType const& value) noexcept
    {
        return { StringTraits::Data(&value), StringTraits::Size(&value) };
    }
};
 
// SqlDataBinder<> specialization for UTF-16 strings
template <typename Utf16StringType>
    requires(SqlBasicStringBinderConcept<Utf16StringType, char16_t>
             || (SqlBasicStringBinderConcept<Utf16StringType, unsigned short>)
             || (SqlBasicStringBinderConcept<Utf16StringType, wchar_t> && sizeof(wchar_t) == 2))
struct SqlDataBinder<Utf16StringType>
{
    using ValueType = Utf16StringType;
    using CharType = std::remove_cvref_t<decltype(std::declval<Utf16StringType>()[0])>;
    using StringTraits = SqlBasicStringOperations<Utf16StringType>;
 
    static constexpr auto ColumnType = StringTraits::ColumnType;
 
    static constexpr auto CType = SQL_C_WCHAR;
 
    static SQLRETURN InputParameter(SQLHSTMT stmt,
                                    SQLUSMALLINT column,
                                    Utf16StringType const& value,
                                    SqlDataBinderCallback& cb) noexcept
    {
        switch (cb.ServerType())
        {
            case SqlServerType::POSTGRESQL: {
                // PostgreSQL only supports UTF-8 as Unicode encoding
                auto u8String = std::make_shared<std::u8string>(ToUtf8(detail::SqlViewHelper<Utf16StringType>::View(value)));
                cb.PlanPostExecuteCallback([u8String = u8String]() {}); // Keep the string alive
                return SQLBindParameter(stmt,
                                        column,
                                        SQL_PARAM_INPUT,
                                        SQL_C_CHAR,
                                        SQL_VARCHAR,
                                        u8String->size(),
                                        0,
                                        (SQLPOINTER) u8String->data(),
                                        0,
                                        nullptr);
            }
            case SqlServerType::ORACLE:
            case SqlServerType::MYSQL:
            case SqlServerType::SQLITE: // We assume UTF-16 for SQLite
            case SqlServerType::MICROSOFT_SQL:
            case SqlServerType::UNKNOWN: {
                using CharType = StringTraits::CharType;
                auto const* data = StringTraits::Data(&value);
                auto const sizeInBytes = StringTraits::Size(&value) * sizeof(CharType);
                auto const charCount = StringTraits::Size(&value);
                auto const sqlType =
                    static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
                return SQLBindParameter(
                    stmt, column, SQL_PARAM_INPUT, CType, sqlType, charCount, 0, (SQLPOINTER) data, sizeInBytes, nullptr);
            }
        }
        std::unreachable();
    }
 
    static SQLRETURN OutputColumn(
        SQLHSTMT stmt, SQLUSMALLINT column, Utf16StringType* result, SQLLEN* indicator, SqlDataBinderCallback& cb) noexcept
    {
        if constexpr (requires { Utf16StringType::Capacity; })
            StringTraits::Resize(result, Utf16StringType::Capacity);
        else if (StringTraits::Size(result) == 0)
            StringTraits::Resize(result, 255);
 
        if constexpr (requires { StringTraits::PostProcessOutputColumn(result, *indicator); })
        {
            cb.PlanPostProcessOutputColumn(
                [indicator, result]() { StringTraits::PostProcessOutputColumn(result, *indicator); });
        }
        else
        {
            cb.PlanPostProcessOutputColumn([stmt, column, indicator, result]() {
                // Now resize the string to the actual length of the data
                // NB: If the indicator is greater than the buffer size, we have a truncation.
                if (*indicator == SQL_NULL_DATA)
                    StringTraits::Resize(result, 0);
                else if (*indicator == SQL_NO_TOTAL)
                    ; // We don't know the size of the data
                else if (*indicator <= static_cast<SQLLEN>(result->size() * sizeof(char16_t)))
                    result->resize(*indicator / sizeof(char16_t));
                else
                {
                    auto const totalCharsRequired = static_cast<SQLLEN>(*indicator / sizeof(char16_t));
                    *indicator += sizeof(char16_t); // Add space to hold the null terminator
                    result->resize(totalCharsRequired);
                    auto const sqlResult = SQLGetData(stmt, column, SQL_C_WCHAR, result->data(), *indicator, indicator);
                    (void) sqlResult;
                    assert(SQL_SUCCEEDED(sqlResult));
                    assert(std::cmp_equal(*indicator, totalCharsRequired * sizeof(char16_t)));
                }
            });
        }
        return SQLBindCol(
            stmt, column, CType, (SQLPOINTER) StringTraits::Data(result), (SQLLEN) StringTraits::Size(result), indicator);
    }
 
    static SQLRETURN GetColumn(SQLHSTMT stmt,
                               SQLUSMALLINT column,
                               Utf16StringType* result,
                               SQLLEN* indicator,
                               SqlDataBinderCallback const& cb) noexcept
    {
        return detail::GetColumnUtf16(stmt, column, result, indicator, cb);
    }
 
    static LIGHTWEIGHT_FORCE_INLINE std::string Inspect(Utf16StringType const& value) noexcept
    {
        auto u8String = ToUtf8(detail::SqlViewHelper<Utf16StringType>::View(value));
        return std::string(reinterpret_cast<char const*>(u8String.data()), u8String.size());
    }
};
 
// SqlDataBinder<> specialization for UTF-32 strings
template <typename Utf32StringType>
    requires(SqlBasicStringBinderConcept<Utf32StringType, char32_t>
             || (SqlBasicStringBinderConcept<Utf32StringType, uint32_t>)
             || (SqlBasicStringBinderConcept<Utf32StringType, wchar_t> && sizeof(wchar_t) == 4))
struct SqlDataBinder<Utf32StringType>
{
    using ValueType = Utf32StringType;
    using CharType = typename Utf32StringType::value_type;
    using StringTraits = SqlBasicStringOperations<Utf32StringType>;
 
    static constexpr auto ColumnType = StringTraits::ColumnType;
 
    static SQLRETURN InputParameter(SQLHSTMT stmt,
                                    SQLUSMALLINT column,
                                    Utf32StringType const& value,
                                    SqlDataBinderCallback& cb) noexcept
    {
        switch (cb.ServerType())
        {
            case SqlServerType::POSTGRESQL: {
                // PostgreSQL only supports UTF-8 as Unicode encoding
                auto u8String = std::make_shared<std::u8string>(ToUtf8(detail::SqlViewHelper<Utf32StringType>::View(value)));
                cb.PlanPostExecuteCallback([u8String = u8String]() {}); // Keep the string alive
                return SQLBindParameter(stmt,
                                        column,
                                        SQL_PARAM_INPUT,
                                        SQL_C_CHAR,
                                        SQL_VARCHAR,
                                        u8String->size(),
                                        0,
                                        (SQLPOINTER) u8String->data(),
                                        0,
                                        nullptr);
            }
            case SqlServerType::ORACLE:
            case SqlServerType::MYSQL:
            case SqlServerType::SQLITE: // We assume UTF-16 for SQLite
            case SqlServerType::MICROSOFT_SQL:
            case SqlServerType::UNKNOWN: {
                auto u16String =
                    std::make_shared<std::u16string>(ToUtf16(detail::SqlViewHelper<Utf32StringType>::View(value)));
                cb.PlanPostExecuteCallback([u8String = u16String]() {}); // Keep the string alive
                auto const* data = u16String->data();
                auto const charCount = u16String->size();
                auto const sizeInBytes = u16String->size() * sizeof(char16_t);
                auto const CType = SQLSMALLINT { SQL_C_WCHAR };
                auto const sqlType =
                    static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
                return SQLBindParameter(
                    stmt, column, SQL_PARAM_INPUT, CType, sqlType, charCount, 0, (SQLPOINTER) data, sizeInBytes, nullptr);
            }
        }
        std::unreachable();
    }
 
    static SQLRETURN OutputColumn(
        SQLHSTMT stmt, SQLUSMALLINT column, Utf32StringType* result, SQLLEN* indicator, SqlDataBinderCallback& cb) noexcept
    {
        return detail::BindOutputColumnNonUtf16Unicode<Utf32StringType>(stmt, column, result, indicator, cb);
    }
 
    static SQLRETURN GetColumn(SQLHSTMT stmt,
                               SQLUSMALLINT column,
                               Utf32StringType* result,
                               SQLLEN* indicator,
                               SqlDataBinderCallback const& cb) noexcept
    {
        auto u16String = std::u16string {};
        auto const sqlResult = detail::GetColumnUtf16(stmt, column, &u16String, indicator, cb);
        if (!SQL_SUCCEEDED(sqlResult))
            return sqlResult;
 
        auto const u32String = ToUtf32(u16String);
        StringTraits::Resize(result, u32String.size());
        std::copy_n((CharType const*) u32String.data(), u32String.size(), StringTraits::Data(result));
 
        return sqlResult;
    }
 
    static LIGHTWEIGHT_FORCE_INLINE std::string Inspect(Utf32StringType const& value) noexcept
    {
        auto u8String = ToUtf8(detail::SqlViewHelper<Utf32StringType>::View(value));
        return std::string(reinterpret_cast<char const*>(u8String.data()), u8String.size());
    }
};
 
// SqlDataBinder<> specialization for UTF-8 strings
template <typename Utf8StringType>
    requires SqlBasicStringBinderConcept<Utf8StringType, char8_t>
struct SqlDataBinder<Utf8StringType>
{
    using ValueType = Utf8StringType;
    using CharType = char8_t;
    using StringTraits = SqlBasicStringOperations<Utf8StringType>;
 
    static constexpr auto ColumnType = StringTraits::ColumnType;
 
    static SQLRETURN InputParameter(SQLHSTMT stmt,
                                    SQLUSMALLINT column,
                                    Utf8StringType const& value,
                                    SqlDataBinderCallback& cb) noexcept
    {
        switch (cb.ServerType())
        {
            case SqlServerType::POSTGRESQL: {
                // PostgreSQL only supports UTF-8 as Unicode encoding
                return SQLBindParameter(stmt,
                                        column,
                                        SQL_PARAM_INPUT,
                                        SQL_C_CHAR,
                                        SQL_VARCHAR,
                                        value.size(),
                                        0,
                                        (SQLPOINTER) value.data(),
                                        0,
                                        nullptr);
            }
            case SqlServerType::ORACLE:
            case SqlServerType::MYSQL:
            case SqlServerType::SQLITE: // We assume UTF-16 for SQLite
            case SqlServerType::MICROSOFT_SQL:
            case SqlServerType::UNKNOWN: {
                auto u16String =
                    std::make_shared<std::u16string>(ToUtf16(detail::SqlViewHelper<Utf8StringType>::View(value)));
                cb.PlanPostExecuteCallback([u16String = u16String]() {}); // Keep the string alive
 
                auto const CType = SQL_C_WCHAR;
                auto const charCount = u16String->size();
                auto const byteCount = u16String->size() * sizeof(char16_t);
                auto const sqlType =
                    static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
                return SQLBindParameter(stmt,
                                        column,
                                        SQL_PARAM_INPUT,
                                        CType,
                                        sqlType,
                                        charCount,
                                        0,
                                        (SQLPOINTER) u16String->data(),
                                        byteCount,
                                        nullptr);
            }
        }
        std::unreachable();
    }
 
    static SQLRETURN OutputColumn(
        SQLHSTMT stmt, SQLUSMALLINT column, Utf8StringType* result, SQLLEN* indicator, SqlDataBinderCallback& cb) noexcept
    {
        return detail::BindOutputColumnNonUtf16Unicode<Utf8StringType>(stmt, column, result, indicator, cb);
    }
 
    static SQLRETURN GetColumn(SQLHSTMT stmt,
                               SQLUSMALLINT column,
                               Utf8StringType* result,
                               SQLLEN* indicator,
                               SqlDataBinderCallback const& cb) noexcept
    {
        auto u16String = std::u16string {};
        u16String.resize(result->size());
        auto const sqlReturn = detail::GetColumnUtf16(stmt, column, &u16String, indicator, cb);
        if (SQL_SUCCEEDED(sqlReturn))
            *result = ToUtf8(u16String);
        return sqlReturn;
    }
 
    static LIGHTWEIGHT_FORCE_INLINE std::string Inspect(Utf8StringType const& value) noexcept
    {
        // Pass data as-is
        return std::string(reinterpret_cast<char const*>(value.data()), value.size());
    }
};
 
} // namespace Lightweight