blitz_query_cpp

1
#include "data/sql/sql_expr.hpp"
2
#include <algorithm>
3
#include <string_view>
4

5
namespace blitz_query_cpp::sql
6
{
7
    sql_expr_t &sql_expr_t::add_child(sql_expr_type t, std::string_view val)
8
    {
9
        return children.emplace_back(t, val);
10
    }
11

12
    sql_expr_t &create_or_get_child_with_type(sql_expr_t &node, sql_expr_type type, std::string_view val = {})
13
    {
14
        auto res = std::find_if(node.children.rbegin(), node.children.rend(), [type](auto &v)
15
                                { return v.type <= type; });
16

17
        if (res == node.children.rend() || res->type != type)
18
        {
19
            return *node.children.emplace(res.base(), type, val);
20
        }
21

22
        return *res;
23
    }
24

25
    sql_expr_t &create_child_with_type(sql_expr_t &node, sql_expr_type type, std::string_view val = {})
26
    {
27
        auto res = std::find_if(node.children.rbegin(), node.children.rend(), [type](auto &v)
28
                                { return v.type <= type; });
29

30
        return *node.children.emplace(res.base(), type, val);
31
    }
32

33
    sql_expr_t select(std::span<const std::string_view> columns)
34
    {
35
        sql_expr_t res{sql_expr_type::Select};
36
        auto &selection = res.add_child(sql_expr_type::SelectColumns);
37
        for (auto col : columns)
38
        {
39
            selection.add_child(sql_expr_type::Column, col);
40
        }
41
        return res;
42
    }
43

44
    sql_expr_t &operator|(sql_expr_t &expr, from_expr_t &&from_expr)
45
    {
46
        auto &res = create_or_get_child_with_type(expr, sql_expr_type::From);
47
        res.children.emplace_back(std::move(from_expr.expr));
48
        return expr;
49
    }
50

51
    sql_expr_t &operator|(sql_expr_t &expr, where_expr_t &&cond)
52
    {
53
        sql_expr_t &where_node = create_or_get_child_with_type(expr, sql_expr_type::Where);
54
        where_node.children.emplace_back(std::move(cond.expr));
55
        return expr;
56
    }
57

58
    sql_expr_t &operator|(sql_expr_t &expr, or_expr_t &&cond)
59
    {
60
        sql_expr_t &where_node = create_or_get_child_with_type(expr, sql_expr_type::Where);
61
        sql_expr_t *op_parent_node = &where_node;
62

63
        if (where_node.children.size() > 0)
64
        {
65
            sql_expr_t or_op{sql_expr_type::Or};
66
            if (where_node.children.size() > 1)
67
            {
68
                auto &and_node = or_op.add_child(sql_expr_type::And);
69
                and_node.children = std::move(where_node.children);
70
            }
71
            else
72
            {
73
                or_op.children = std::move(where_node.children);
74
            }
75
            op_parent_node = &where_node.children.emplace_back(std::move(or_op));
76
        }
77

78
        op_parent_node->children.emplace_back(std::move(cond.expr));
79
        return expr;
80
    }
81

82
    sql_expr_t binary_operation(binary_op op, sql_expr_t &&a, sql_expr_t &&b)
83
    {
84
        sql_expr_t res{get_expr_type(op)};
85
        res.children.emplace_back(std::move(a));
86
        res.children.emplace_back(std::move(b));
87
        return res;
88
    }
89

90
    sql_expr_t binary_operation(binary_op op, const sql_expr_t &a, const sql_expr_t &b)
91
    {
92
        sql_expr_t res{get_expr_type(op)};
93
        res.children.emplace_back(a);
94
        res.children.emplace_back(b);
95
        return res;
96
    }
97

98
    sql_expr_t &operator|(sql_expr_t &expr, order_by_t &&param)
99
    {
100
        sql_expr_t &order_node = create_or_get_child_with_type(expr, sql_expr_type::Order);
101
        order_node.children.emplace_back(param.ascending ? sql_expr_type::Asc : sql_expr_type::Desc, "", std::move(param.column));
102
        return expr;
103
    }
104

105
    sql_expr_t &operator|(sql_expr_t &expr, limit_t param)
106
    {
107
        sql_expr_t &node = create_or_get_child_with_type(expr, sql_expr_type::Limit);
108
        node.value = std::to_string(param.value);
109
        return expr;
110
    }
111

112
    sql_expr_t &operator|(sql_expr_t &expr, offset_t param)
113
    {
114
        sql_expr_t &node = create_or_get_child_with_type(expr, sql_expr_type::Offset);
115
        node.value = std::to_string(param.value);
116
        return expr;
117
    }
118

119
    sql_expr_t &operator|(sql_expr_t &expr, join_t &&param)
120
    {
121
        sql_expr_t &join_node = create_child_with_type(expr, get_expr_type(param.kind));
122
        join_node.children.emplace_back(std::move(param.expr));
123
        sql_expr_t &on_node = join_node.add_child(sql_expr_type::On);
124
        on_node.children.emplace_back(std::move(param.column1));
125
        on_node.children.emplace_back(std::move(param.column2));
126
        return expr;
127
    }
128

129
    sql_expr_t &operator|(sql_expr_t &expr, column_t &&param)
130
    {
131
        auto &columns = create_or_get_child_with_type(expr, sql_expr_type::SelectColumns);
132
        columns.children.emplace_back(std::move(param.expr));
133
        return expr;
134
    }
135

136
}