class sql_query_builder { ... };      // Lines 110-188
class mongodb_query_builder { ... };   // Lines 194-266
class redis_query_builder { ... };     // Lines 277-322
class query_builder { ... };           // Lines 328-368 (Universal)

class query_builder {
private:
    database_types db_type_;
    std::unique_ptr<sql_query_builder> sql_builder_;
    std::unique_ptr<mongodb_query_builder> mongo_builder_;
    std::unique_ptr<redis_query_builder> redis_builder_;
};

namespace database {

// Strategy interface
class query_dialect {
public:
    virtual ~query_dialect() = default;
    virtual std::string format_select(const std::vector<std::string>& cols) const = 0;
    virtual std::string format_from(const std::string& table) const = 0;
    virtual std::string format_where(const query_condition& cond) const = 0;
    virtual std::string format_value(const database_value& val) const = 0;
    virtual std::string build() const = 0;
};

// Concrete strategies (internal)
namespace detail {
    class sql_dialect final : public query_dialect { ... };
    class mongodb_dialect final : public query_dialect { ... };
    class redis_dialect final : public query_dialect { ... };
}

// Unified builder
class query_builder {
public:
    explicit query_builder(database_types db_type);
    
    // Fluent interface
    query_builder& select(const std::vector<std::string>& columns);
    query_builder& from(const std::string& table);
    query_builder& where(const std::string& field, const std::string& op, 
                         const database_value& value);
    
    std::string build() const;
    
private:
    std::unique_ptr<query_dialect> dialect_;  // Only ONE allocated
};

} // namespace database

std::unique_ptr<query_dialect> create_dialect(database_types type) {
    switch (type) {
        case database_types::postgresql:
        case database_types::mysql:
        case database_types::sqlite:
            return std::make_unique<detail::sql_dialect>(type);
        case database_types::mongodb:
            return std::make_unique<detail::mongodb_dialect>();
        case database_types::redis:
            return std::make_unique<detail::redis_dialect>();
        default:
            throw std::invalid_argument("Unsupported database type");
    }
}

class [[deprecated("Use query_builder instead")]] sql_query_builder { ... };
class [[deprecated("Use query_builder instead")]] mongodb_query_builder { ... };
class [[deprecated("Use query_builder instead")]] redis_query_builder { ... };