Thread-safe immutable query builder using functional programming style. More...

#include <immutable_query_builder.h>

Collaboration diagram for database::immutable_query_builder:

Public Member Functions
	immutable_query_builder (const std::string &table)
	Constructs a new immutable query builder.

immutable_query_builder	select (std::vector< std::string > fields) const
	SELECT clause - specifies which columns to select.

immutable_query_builder	where (const std::string &field, const std::string &op, const core::database_value &value) const
	WHERE clause - adds a condition.

immutable_query_builder	where (const query_condition &condition) const
	WHERE clause - adds a query_condition.

immutable_query_builder	order_by (const std::string &field, sort_order order=sort_order::asc) const
	ORDER BY clause - specifies sorting.

immutable_query_builder	limit (uint32_t count) const
	LIMIT clause - limits number of results.

immutable_query_builder	offset (uint32_t count) const
	OFFSET clause - skips rows.

immutable_query_builder	join (const std::string &table, const std::string &condition, join_type type=join_type::inner) const
	JOIN clause - adds a join.

immutable_query_builder	group_by (std::vector< std::string > fields) const
	GROUP BY clause - groups results.

immutable_query_builder	having (const std::string &condition) const
	HAVING clause - filters grouped results.

std::string	build () const
	Builds the final SQL query string.

std::string	build_for_database (database_types db_type) const
	Builds the SQL query for a specific database type.

Private Member Functions
	immutable_query_builder (std::string table, std::vector< std::string > select_fields, std::vector< query_condition > conditions, std::vector< std::pair< std::string, sort_order > > order_by, std::optional< uint32_t > limit, std::optional< uint32_t > offset, std::vector< std::tuple< std::string, std::string, join_type > > joins, std::vector< std::string > group_by_fields, std::string having_clause)

std::string	escape_identifier (const std::string &identifier, database_types db_type) const

std::string	format_value (const core::database_value &value, database_types db_type) const

std::string	join_type_to_string (join_type type) const

Private Attributes
const std::string	table_

const std::vector< std::string >	select_fields_

const std::vector< query_condition >	conditions_

const std::vector< std::pair< std::string, sort_order > >	order_by_

const std::optional< uint32_t >	limit_

const std::optional< uint32_t >	offset_

const std::vector< std::tuple< std::string, std::string, join_type > >	joins_

const std::vector< std::string >	group_by_fields_

const std::string	having_clause_

Detailed Description

Thread-safe immutable query builder using functional programming style.

Thread Safety

FULLY thread-safe. All methods are const and return new instances.
No mutable state. All fields are const.
Safe to share instances across threads.
Immutable builder pattern ensures no race conditions.

Design

Each method returns a new instance with updated state.
Original instance remains unchanged.
Functional programming style (copy-on-write).
No locks needed due to immutability.

Usage Example

auto query = immutable_query_builder("users")
    .select({"id", "name", "email"})
    .where("active", "=", true)
    .order_by("name", sort_order::asc)
    .limit(10)
    .build();

Definition at line 43 of file immutable_query_builder.h.

Constructor & Destructor Documentation

◆ immutable_query_builder() [1/2]

database::immutable_query_builder::immutable_query_builder ( const std::string & table )

explicit

Constructs a new immutable query builder.

Parameters

table Table name for the query.

Definition at line 12 of file immutable_query_builder.cpp.

        : table_(table)
        , select_fields_()
        , conditions_()
        , order_by_()
        , limit_(std::nullopt)
        , offset_(std::nullopt)
        , joins_()
        , group_by_fields_()
        , having_clause_()
    {
    }

Referenced by group_by(), having(), join(), limit(), offset(), order_by(), select(), where(), and where().

Here is the caller graph for this function:

◆ immutable_query_builder() [2/2]

database::immutable_query_builder::immutable_query_builder	(	std::string	table,
		std::vector< std::string >	select_fields,
		std::vector< query_condition >	conditions,
		std::vector< std::pair< std::string, sort_order > >	order_by,
		std::optional< uint32_t >	limit,
		std::optional< uint32_t >	offset,
		std::vector< std::tuple< std::string, std::string, join_type > >	joins,
		std::vector< std::string >	group_by_fields,
		std::string	having_clause )

private

Definition at line 26 of file immutable_query_builder.cpp.

        : table_(std::move(table))
        , select_fields_(std::move(select_fields))
        , conditions_(std::move(conditions))
        , order_by_(std::move(order_by))
        , limit_(limit)
        , offset_(offset)
        , joins_(std::move(joins))
        , group_by_fields_(std::move(group_by_fields))
        , having_clause_(std::move(having_clause))
    {
    }

Member Function Documentation

◆ build()

std::string database::immutable_query_builder::build ( ) const

Builds the final SQL query string.

Returns: SQL query string.

Thread-safe: No state modification, all fields are const.

Definition at line 196 of file immutable_query_builder.cpp.

    {
        return build_for_database(database_types::postgres);
    }

References build_for_database(), and database::postgres.

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_for_database()

std::string database::immutable_query_builder::build_for_database ( database_types db_type ) const

Builds the SQL query for a specific database type.

Parameters

db_type Database type (PostgreSQL, SQLite, etc.).

Returns: SQL query string formatted for the specified database.

Definition at line 201 of file immutable_query_builder.cpp.

    {
        std::ostringstream query;
 
        // SELECT clause
        query << "SELECT ";
        if (select_fields_.empty())
        {
            query << "*";
        }
        else
        {
            for (size_t i = 0; i < select_fields_.size(); ++i)
            {
                if (i > 0)
                    query << ", ";
                query << escape_identifier(select_fields_[i], db_type);
            }
        }
 
        // FROM clause
        query << " FROM " << escape_identifier(table_, db_type);
 
        // JOIN clauses
        for (const auto& [join_table, join_condition, join_type_val] : joins_)
        {
            query << " " << join_type_to_string(join_type_val) << " JOIN "
                  << escape_identifier(join_table, db_type)
                  << " ON " << join_condition;
        }
 
        // WHERE clause
        if (!conditions_.empty())
        {
            query << " WHERE ";
            for (size_t i = 0; i < conditions_.size(); ++i)
            {
                if (i > 0)
                    query << " AND ";
                query << conditions_[i].to_sql();
            }
        }
 
        // GROUP BY clause
        if (!group_by_fields_.empty())
        {
            query << " GROUP BY ";
            for (size_t i = 0; i < group_by_fields_.size(); ++i)
            {
                if (i > 0)
                    query << ", ";
                query << escape_identifier(group_by_fields_[i], db_type);
            }
        }
 
        // HAVING clause
        if (!having_clause_.empty())
        {
            query << " HAVING " << having_clause_;
        }
 
        // ORDER BY clause
        if (!order_by_.empty())
        {
            query << " ORDER BY ";
            for (size_t i = 0; i < order_by_.size(); ++i)
            {
                if (i > 0)
                    query << ", ";
                query << escape_identifier(order_by_[i].first, db_type) << " "
                      << (order_by_[i].second == sort_order::asc ? "ASC" : "DESC");
            }
        }
 
        // LIMIT clause
        if (limit_.has_value())
        {
            query << " LIMIT " << limit_.value();
        }
 
        // OFFSET clause
        if (offset_.has_value())
        {
            query << " OFFSET " << offset_.value();
        }
 
        return query.str();
    }

References database::asc, conditions_, escape_identifier(), group_by_fields_, having_clause_, join_type_to_string(), joins_, limit_, offset_, order_by_, select_fields_, and table_.

Referenced by build().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ escape_identifier()

std::string database::immutable_query_builder::escape_identifier	(	const std::string &	identifier,
		database_types	db_type ) const

private

Definition at line 290 of file immutable_query_builder.cpp.

    {
        switch (db_type)
        {
        case database_types::postgres:
            return "\"" + identifier + "\"";
        case database_types::sqlite:
            return "\"" + identifier + "\"";
        default:
            return identifier;
        }
    }

References database::postgres, and database::sqlite.

Referenced by build_for_database().

Here is the caller graph for this function:

◆ format_value()

std::string database::immutable_query_builder::format_value	(	const core::database_value &	value,
		database_types	db_type ) const

private

Definition at line 303 of file immutable_query_builder.cpp.

    {
        if (std::holds_alternative<std::string>(value))
        {
            const auto& str = std::get<std::string>(value);
            std::string escaped;
            escaped.reserve(str.size() + 2);
            escaped += "'";
            for (char c : str)
            {
                if (c == '\'')
                    escaped += "''";
                else
                    escaped += c;
            }
            escaped += "'";
            return escaped;
        }
        else if (std::holds_alternative<int64_t>(value))
        {
            return std::to_string(std::get<int64_t>(value));
        }
        else if (std::holds_alternative<double>(value))
        {
            return std::to_string(std::get<double>(value));
        }
        else if (std::holds_alternative<bool>(value))
        {
            return std::get<bool>(value) ? "TRUE" : "FALSE";
        }
        else if (std::holds_alternative<std::nullptr_t>(value))
        {
            return "NULL";
        }
        return "NULL";
    }

◆ group_by()

immutable_query_builder database::immutable_query_builder::group_by ( std::vector< std::string > fields ) const

GROUP BY clause - groups results.

Parameters

fields Fields to group by.

Returns: New immutable_query_builder instance with updated grouping.

Definition at line 166 of file immutable_query_builder.cpp.

    {
        return immutable_query_builder(
            table_,
            select_fields_,
            conditions_,
            order_by_,
            limit_,
            offset_,
            joins_,
            std::move(fields),
            having_clause_
        );
    }

References conditions_, having_clause_, immutable_query_builder(), joins_, limit_, offset_, order_by_, select_fields_, and table_.

Here is the call graph for this function:

◆ having()

immutable_query_builder database::immutable_query_builder::having ( const std::string & condition ) const

HAVING clause - filters grouped results.

Parameters

condition Condition for filtering groups.

Returns: New immutable_query_builder instance with updated having clause.

Definition at line 181 of file immutable_query_builder.cpp.

    {
        return immutable_query_builder(
            table_,
            select_fields_,
            conditions_,
            order_by_,
            limit_,
            offset_,
            joins_,
            group_by_fields_,
            condition
        );
    }

References conditions_, group_by_fields_, immutable_query_builder(), joins_, limit_, offset_, order_by_, select_fields_, and table_.

Here is the call graph for this function:

◆ join()

immutable_query_builder database::immutable_query_builder::join	(	const std::string &	table,
		const std::string &	condition,
		join_type	type = join_type::inner ) const

JOIN clause - adds a join.

Parameters

table	Table to join.
condition	Join condition.
type	Join type (inner, left, right, etc.).

Returns: New immutable_query_builder instance with updated join.

Definition at line 148 of file immutable_query_builder.cpp.

    {
        auto new_joins = joins_;
        new_joins.emplace_back(table, condition, type);
 
        return immutable_query_builder(
            table_,
            select_fields_,
            conditions_,
            order_by_,
            limit_,
            offset_,
            std::move(new_joins),
            group_by_fields_,
            having_clause_
        );
    }

References conditions_, group_by_fields_, having_clause_, immutable_query_builder(), joins_, limit_, offset_, order_by_, select_fields_, and table_.

Here is the call graph for this function:

◆ join_type_to_string()

std::string database::immutable_query_builder::join_type_to_string ( join_type type ) const

private

Definition at line 340 of file immutable_query_builder.cpp.

    {
        switch (type)
        {
        case join_type::inner:
            return "INNER";
        case join_type::left:
            return "LEFT";
        case join_type::right:
            return "RIGHT";
        case join_type::full_outer:
            return "FULL OUTER";
        case join_type::cross:
            return "CROSS";
        default:
            return "INNER";
        }
    }

References database::cross, database::full_outer, database::inner, database::left, and database::right.

Referenced by build_for_database().

Here is the caller graph for this function:

◆ limit()

immutable_query_builder database::immutable_query_builder::limit ( uint32_t count ) const

LIMIT clause - limits number of results.

Parameters

count Maximum number of rows to return.

Returns: New immutable_query_builder instance with updated limit.

Definition at line 118 of file immutable_query_builder.cpp.

    {
        return immutable_query_builder(
            table_,
            select_fields_,
            conditions_,
            order_by_,
            count,
            offset_,
            joins_,
            group_by_fields_,
            having_clause_
        );
    }

References conditions_, group_by_fields_, having_clause_, immutable_query_builder(), joins_, offset_, order_by_, select_fields_, and table_.

Here is the call graph for this function:

◆ offset()

immutable_query_builder database::immutable_query_builder::offset ( uint32_t count ) const

OFFSET clause - skips rows.

Parameters

count Number of rows to skip.

Returns: New immutable_query_builder instance with updated offset.

Definition at line 133 of file immutable_query_builder.cpp.

    {
        return immutable_query_builder(
            table_,
            select_fields_,
            conditions_,
            order_by_,
            limit_,
            count,
            joins_,
            group_by_fields_,
            having_clause_
        );
    }

References conditions_, group_by_fields_, having_clause_, immutable_query_builder(), joins_, limit_, order_by_, select_fields_, and table_.

Here is the call graph for this function:

◆ order_by()

immutable_query_builder database::immutable_query_builder::order_by	(	const std::string &	field,
		sort_order	order = sort_order::asc ) const

ORDER BY clause - specifies sorting.

Parameters

field	Field name to sort by.
order	Sort order (asc or desc).

Returns: New immutable_query_builder instance with updated order.

Definition at line 100 of file immutable_query_builder.cpp.

    {
        auto new_order_by = order_by_;
        new_order_by.emplace_back(field, order);
 
        return immutable_query_builder(
            table_,
            select_fields_,
            conditions_,
            std::move(new_order_by),
            limit_,
            offset_,
            joins_,
            group_by_fields_,
            having_clause_
        );
    }

References conditions_, group_by_fields_, having_clause_, immutable_query_builder(), joins_, limit_, offset_, order_by_, select_fields_, and table_.

Here is the call graph for this function:

◆ select()

immutable_query_builder database::immutable_query_builder::select ( std::vector< std::string > fields ) const

SELECT clause - specifies which columns to select.

Parameters

fields Vector of column names to select.

Returns: New immutable_query_builder instance with updated select fields.

Definition at line 49 of file immutable_query_builder.cpp.

    {
        return immutable_query_builder(
            table_,
            std::move(fields),
            conditions_,
            order_by_,
            limit_,
            offset_,
            joins_,
            group_by_fields_,
            having_clause_
        );
    }

References conditions_, group_by_fields_, having_clause_, immutable_query_builder(), joins_, limit_, offset_, order_by_, and table_.

Here is the call graph for this function:

◆ where() [1/2]

immutable_query_builder database::immutable_query_builder::where ( const query_condition & condition ) const

WHERE clause - adds a query_condition.

Parameters

condition Pre-built query_condition.

Returns: New immutable_query_builder instance with updated conditions.

Definition at line 82 of file immutable_query_builder.cpp.

    {
        auto new_conditions = conditions_;
        new_conditions.push_back(condition);
 
        return immutable_query_builder(
            table_,
            select_fields_,
            std::move(new_conditions),
            order_by_,
            limit_,
            offset_,
            joins_,
            group_by_fields_,
            having_clause_
        );
    }

References conditions_, group_by_fields_, having_clause_, immutable_query_builder(), joins_, limit_, offset_, order_by_, select_fields_, and table_.

Here is the call graph for this function:

◆ where() [2/2]

immutable_query_builder database::immutable_query_builder::where	(	const std::string &	field,
		const std::string &	op,
		const core::database_value &	value ) const

WHERE clause - adds a condition.

Parameters

field	Field name.
op	Operator (e.g., "=", ">", "<", "LIKE").
value	Value to compare against.

Returns: New immutable_query_builder instance with updated conditions.

Definition at line 64 of file immutable_query_builder.cpp.

    {
        auto new_conditions = conditions_;
        new_conditions.emplace_back(field, op, value);
 
        return immutable_query_builder(
            table_,
            select_fields_,
            std::move(new_conditions),
            order_by_,
            limit_,
            offset_,
            joins_,
            group_by_fields_,
            having_clause_
        );
    }

References conditions_, group_by_fields_, having_clause_, immutable_query_builder(), joins_, limit_, offset_, order_by_, select_fields_, and table_.

Here is the call graph for this function:

Member Data Documentation

◆ conditions_

const std::vector<query_condition> database::immutable_query_builder::conditions_

private

Definition at line 139 of file immutable_query_builder.h.

Referenced by build_for_database(), group_by(), having(), join(), limit(), offset(), order_by(), select(), where(), and where().

◆ group_by_fields_

const std::vector<std::string> database::immutable_query_builder::group_by_fields_

private

Definition at line 144 of file immutable_query_builder.h.

Referenced by build_for_database(), having(), join(), limit(), offset(), order_by(), select(), where(), and where().

◆ having_clause_

const std::string database::immutable_query_builder::having_clause_

private

Definition at line 145 of file immutable_query_builder.h.

Referenced by build_for_database(), group_by(), join(), limit(), offset(), order_by(), select(), where(), and where().

◆ joins_

const std::vector<std::tuple<std::string, std::string, join_type> > database::immutable_query_builder::joins_

private

Definition at line 143 of file immutable_query_builder.h.

Referenced by build_for_database(), group_by(), having(), join(), limit(), offset(), order_by(), select(), where(), and where().

◆ limit_

const std::optional<uint32_t> database::immutable_query_builder::limit_

private

Definition at line 141 of file immutable_query_builder.h.

Referenced by build_for_database(), group_by(), having(), join(), offset(), order_by(), select(), where(), and where().

◆ offset_

const std::optional<uint32_t> database::immutable_query_builder::offset_

private

Definition at line 142 of file immutable_query_builder.h.

Referenced by build_for_database(), group_by(), having(), join(), limit(), order_by(), select(), where(), and where().

◆ order_by_

const std::vector<std::pair<std::string, sort_order> > database::immutable_query_builder::order_by_

private

Definition at line 140 of file immutable_query_builder.h.

Referenced by build_for_database(), group_by(), having(), join(), limit(), offset(), order_by(), select(), where(), and where().

◆ select_fields_

const std::vector<std::string> database::immutable_query_builder::select_fields_

private

Definition at line 138 of file immutable_query_builder.h.

Referenced by build_for_database(), group_by(), having(), join(), limit(), offset(), order_by(), where(), and where().

◆ table_

const std::string database::immutable_query_builder::table_

private

Definition at line 137 of file immutable_query_builder.h.

Referenced by build_for_database(), group_by(), having(), join(), limit(), offset(), order_by(), select(), where(), and where().

The documentation for this class was generated from the following files:

database/query/immutable_query_builder.h
database/query/immutable_query_builder.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Thread Safety

Design

Usage Example

Constructor & Destructor Documentation

◆ immutable_query_builder() [1/2]

◆ immutable_query_builder() [2/2]

Member Function Documentation

◆ build()

◆ build_for_database()

◆ escape_identifier()

◆ format_value()

◆ group_by()

◆ having()

◆ join()

◆ join_type_to_string()

◆ limit()

◆ offset()

◆ order_by()

◆ select()

◆ where() [1/2]

◆ where() [2/2]

Member Data Documentation

◆ conditions_

◆ group_by_fields_

◆ having_clause_

◆ joins_

◆ limit_

◆ offset_

◆ order_by_

◆ select_fields_

◆ table_