SqlQuery.hpp

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include "Api.hpp"
#include "SqlQuery/Delete.hpp"
#include "SqlQuery/Insert.hpp"
#include "SqlQuery/Migrate.hpp"
#include "SqlQuery/Select.hpp"
#include "SqlQuery/Update.hpp"
 
namespace Lightweight
{
 
/// @defgroup QueryBuilder Query Builder
/// @brief Classes and functions for building SQL queries.
 
struct [[nodiscard]] SqlLastInsertIdQuery
{
    std::string tableName;
    SqlQueryFormatter const* formatter;
 
    [[nodiscard]] std::string ToSql() const
    {
        return formatter->QueryLastInsertId(tableName);
    }
};
 
/// @brief API Entry point for building SQL queries.
///
/// @ingroup QueryBuilder
class [[nodiscard]] SqlQueryBuilder final
{
  public:
    /// Constructs a new query builder for the given table.
    explicit SqlQueryBuilder(SqlQueryFormatter const& formatter,
                             std::string&& table = {},
                             std::string&& alias = {}) noexcept;
 
    /// Constructs a new query builder for the given table.
    LIGHTWEIGHT_API SqlQueryBuilder& FromTable(std::string table);
 
    /// Constructs a new query builder for the given table.
    LIGHTWEIGHT_API SqlQueryBuilder& FromTable(std::string_view table);
 
    /// Constructs a new query builder for the given table.
    template <size_t N>
    SqlQueryBuilder& FromTable(char const (&table)[N])
    {
        return FromTable(std::string_view { table, N - 1 });
    }
 
    /// Constructs a new query builder for the given table with an alias.
    LIGHTWEIGHT_API SqlQueryBuilder& FromTableAs(std::string table, std::string alias);
 
    /// Constructs a new query builder for the given schema and table.
    /// @param schema The schema name (e.g., "public", "dbo")
    /// @param table The table name
    LIGHTWEIGHT_API SqlQueryBuilder& FromSchemaTable(std::string_view schema, std::string_view table);
 
    ///  Initiates INSERT query building
    ///
    ///  @param boundInputs Optional vector to store bound inputs.
    ///                     If provided, the inputs will be appended to this vector and can be used
    ///                    to bind the values to the query via SqlStatement::ExecuteWithVariants(...)
    LIGHTWEIGHT_API SqlInsertQueryBuilder Insert(std::vector<SqlVariant>* boundInputs = nullptr) noexcept;
 
    /// Constructs a query to retrieve the last insert ID for the given table.
    LIGHTWEIGHT_API SqlLastInsertIdQuery LastInsertId();
 
    /// Initiates SELECT query building.
    ///
    /// Returns a @ref SqlSelectQueryStarter — a type that intentionally does not
    /// expose @c All / @c First / @c Range, so `Select().All()` and the equivalent
    /// `auto q = Select(); q.All();` (both empty-projection patterns) fail to
    /// compile. Add a column via `.Field(...)`, `.Fields(...)`, `.FieldAs(...)`,
    /// or `.Build([](auto& q){ ... })` — each returns a `SqlSelectQueryBuilder&`
    /// that exposes the finalizers. `.Count()` is exposed on the starter directly,
    /// since `SELECT COUNT(*)` is well-formed without an explicit field list.
    ///
    /// @param boundInputs Optional vector to store bound inputs.
    ///                    If provided, the WHERE values will be appended to this vector as parameter
    ///                    markers instead of being written into the query text, and the query must
    ///                    then be run via SqlStatement::ExecuteWithVariants(...) rather than
    ///                    ExecuteDirect(...). See SqlSelectQueryBuilder's constructor for the
    ///                    lifetime and marker-count caveats.
    LIGHTWEIGHT_API SqlSelectQueryStarter Select(std::vector<SqlVariant>* boundInputs = nullptr) noexcept;
 
    /// Initiates UPDATE query building.
    ///
    /// @param boundInputs Optional vector to store bound inputs.
    ///                    If provided, the inputs will be appended to this vector and can be used
    ///                    to bind the values to the query via SqlStatement::ExecuteWithVariants(...)
    LIGHTWEIGHT_API SqlUpdateQueryBuilder Update(std::vector<SqlVariant>* boundInputs = nullptr) noexcept;
 
    /// Initiates DELETE query building.
    ///
    /// @param boundInputs Optional vector to store bound inputs.
    ///                    If provided, the WHERE values will be appended to this vector as parameter
    ///                    markers instead of being written into the query text, and the query must
    ///                    then be run via SqlStatement::ExecuteWithVariants(...) rather than
    ///                    ExecuteDirect(...). See SqlDeleteQueryBuilder's constructor for the
    ///                    lifetime and marker-count caveats.
    LIGHTWEIGHT_API SqlDeleteQueryBuilder Delete(std::vector<SqlVariant>* boundInputs = nullptr) noexcept;
 
    /// Initiates query for building database migrations.
    LIGHTWEIGHT_API SqlMigrationQueryBuilder Migration();
 
  private:
    SqlQueryFormatter const& m_formatter;
    std::string m_schema;
    std::string m_table;
    std::string m_tableAlias;
};
 
inline LIGHTWEIGHT_FORCE_INLINE SqlQueryBuilder::SqlQueryBuilder(SqlQueryFormatter const& formatter,
                                                                 std::string&& table,
                                                                 std::string&& alias) noexcept:
    m_formatter { formatter },
    m_table { std::move(table) },
    m_tableAlias { std::move(alias) }
{
}
 
} // namespace Lightweight