Update.hpp

// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#include "Core.hpp"
 
#include <string>
#include <string_view>
#include <vector>
 
namespace Lightweight
{
 
/// @brief Query builder for building UPDATE ... queries.
///
/// @ingroup QueryBuilder
class [[nodiscard]] SqlUpdateQueryBuilder final: public SqlWhereClauseBuilder<SqlUpdateQueryBuilder>
{
  public:
    /// Constructs a new SqlUpdateQueryBuilder object.
    ///
    /// @param formatter The SQL query formatter to use. One of SqlServerQueryFormatter, PostgreSqlFormatter
    /// @param table The name of the table to update.
    /// @param tableAlias The alias of the table to update.
    /// @param inputBindings The input bindings to use for the query.
    SqlUpdateQueryBuilder(SqlQueryFormatter const& formatter,
                          std::string table,
                          std::string tableAlias,
                          std::vector<SqlVariant>* inputBindings) noexcept:
        SqlWhereClauseBuilder<SqlUpdateQueryBuilder> {},
        m_formatter { formatter }
    {
        m_searchCondition.tableName = std::move(table);
        m_searchCondition.tableAlias = std::move(tableAlias);
        m_searchCondition.inputBindings = inputBindings;
    }
 
    /// Returns the search condition for the query.
    SqlSearchCondition& SearchCondition() noexcept // NOLINT(bugprone-derived-method-shadowing-base-method)
    {
        return m_searchCondition;
    }
 
    /// @brief Returns the SQL query formatter.
    ///
    /// Named Formatter() because SqlWhereClauseBuilder resolves it through the CRTP derived type;
    /// the apparent shadowing is the mechanism, not an accident.
    [[nodiscard]] SqlQueryFormatter const& Formatter()
        const noexcept // NOLINT(bugprone-derived-method-shadowing-base-method)
    {
        return m_formatter;
    }
 
    /// Adds a single column to the SET clause.
    template <typename ColumnValue>
    SqlUpdateQueryBuilder& Set(std::string_view columnName, ColumnValue const& value);
 
    /// Adds a single column to the SET clause with the value being a string literal.
    template <std::size_t N>
    SqlUpdateQueryBuilder& Set(std::string_view columnName, char const (&value)[N]);
 
    /// Finalizes building the query as UPDATE ... query.
    [[nodiscard]] std::string ToSql() const;
 
  private:
    SqlQueryFormatter const& m_formatter;
    std::string m_values;
    SqlSearchCondition m_searchCondition;
};
 
template <typename ColumnValue>
SqlUpdateQueryBuilder& SqlUpdateQueryBuilder::Set(std::string_view columnName, ColumnValue const& value)
{
    using namespace std::string_view_literals;
 
    if (!m_values.empty())
        m_values += ", "sv;
 
    m_values += '"';
    m_values += columnName;
    m_values += R"(" = )"sv;
 
    if constexpr (std::is_same_v<ColumnValue, SqlNullType>)
        m_values += "NULL"sv;
    else if constexpr (std::is_same_v<ColumnValue, SqlWildcardType>)
        m_values += '?';
    else if constexpr (std::is_same_v<ColumnValue, SqlVariant>)
    {
        // A NULL variant becomes the SQL literal NULL rather than a bound parameter -- see the same
        // branch in SqlInsertQueryBuilder::Set (Insert.hpp) for why a bound NULL cannot be typed
        // reliably on MS SQL Server (SQLDescribeParam is rejected with 07009 once a parameter has been
        // bound). A literal needs no type resolution.
        if (value.IsNull())
            m_values += "NULL"sv;
        else if (m_searchCondition.inputBindings)
        {
            m_values += '?';
            m_searchCondition.inputBindings->emplace_back(value);
        }
        else
            m_values += m_formatter.StringLiteral(std::format("{}", value));
    }
    else if (m_searchCondition.inputBindings)
    {
        m_values += '?';
        m_searchCondition.inputBindings->emplace_back(value);
    }
    else if constexpr (std::is_same_v<ColumnValue, char>)
        m_values += m_formatter.StringLiteral(value);
    else if constexpr (std::is_arithmetic_v<ColumnValue>)
        m_values += std::format("{}", value);
    else if constexpr (!WhereConditionLiteralType<ColumnValue>::needsQuotes)
        m_values += std::format("{}", value);
    else
    {
        // Route through the formatter rather than quoting by hand: it escapes embedded quotes and
        // applies the dialect's literal rules (e.g. SQL Server's N'…' + NCHAR() encoding).
        // SqlInsertQueryBuilder::Set does the same — see Insert.hpp.
        m_values += m_formatter.StringLiteral(std::format("{}", value));
    }
 
    return *this;
}
 
template <std::size_t N>
SqlUpdateQueryBuilder& SqlUpdateQueryBuilder::Set(std::string_view columnName, char const (&value)[N])
{
    return Set(columnName, std::string_view { value, N - 1 });
}
 
inline LIGHTWEIGHT_FORCE_INLINE std::string SqlUpdateQueryBuilder::ToSql() const
{
    return m_formatter.Update(
        m_searchCondition.tableName, m_searchCondition.tableAlias, m_values, m_searchCondition.condition);
}
 
} // namespace Lightweight