-
Notifications
You must be signed in to change notification settings - Fork 224
Expand file tree
/
Copy pathexpr.cpp
More file actions
156 lines (137 loc) · 6.28 KB
/
Copy pathexpr.cpp
File metadata and controls
156 lines (137 loc) · 6.28 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors
#include "expr.h"
#include "duckdb/function/scalar_function.hpp"
#include "duckdb/function/aggregate_function.hpp"
#include "duckdb/planner/expression/bound_between_expression.hpp"
#include "duckdb/planner/expression/bound_cast_expression.hpp"
#include "duckdb/planner/expression/bound_columnref_expression.hpp"
#include "duckdb/planner/expression/bound_comparison_expression.hpp"
#include "duckdb/planner/expression/bound_constant_expression.hpp"
#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
#include "duckdb/planner/expression/bound_function_expression.hpp"
#include "duckdb/planner/expression/bound_operator_expression.hpp"
#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
using namespace duckdb;
extern "C" const char *duckdb_vx_sfunc_name(duckdb_vx_sfunc ffi_func) {
if (!ffi_func) {
return nullptr;
}
auto func = reinterpret_cast<ScalarFunction *>(ffi_func);
return func->name.c_str();
}
extern "C" const char *duckdb_vx_agg_func_name(duckdb_vx_agg_func ffi) {
D_ASSERT(ffi);
return reinterpret_cast<AggregateFunction *>(ffi)->name.c_str();
}
extern "C" const char *duckdb_vx_expr_to_string(duckdb_vx_expr ffi_expr) {
if (!ffi_expr) {
return nullptr;
}
auto expr = reinterpret_cast<Expression *>(ffi_expr);
auto str = expr->ToString();
auto result = static_cast<char *>(duckdb_malloc(str.size() + 1));
memcpy(result, str.c_str(), str.size() + 1);
return result;
}
extern "C" void duckdb_vx_destroy_expr(duckdb_vx_expr *ffi_expr) {
auto expr = reinterpret_cast<Expression *>(ffi_expr);
delete expr;
memset(ffi_expr, 0, sizeof(duckdb_vx_expr));
}
extern "C" duckdb_vx_expr_class duckdb_vx_expr_get_class(duckdb_vx_expr ffi_expr) {
if (!ffi_expr) {
return DUCKDB_VX_EXPR_CLASS_INVALID;
}
auto expr = reinterpret_cast<Expression *>(ffi_expr);
return static_cast<duckdb_vx_expr_class>(expr->GetExpressionClass());
}
extern "C" duckdb_logical_type duckdb_vx_expr_get_return_type(duckdb_vx_expr ffi_expr) {
D_ASSERT(ffi_expr);
auto expr = reinterpret_cast<Expression *>(ffi_expr);
return reinterpret_cast<duckdb_logical_type>(&expr->return_type);
}
extern "C" const char *duckdb_vx_expr_get_bound_column_ref_get_name(duckdb_vx_expr ffi_expr) {
if (!ffi_expr) {
return nullptr;
}
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundColumnRefExpression>();
auto str = expr.GetName();
auto result = static_cast<char *>(duckdb_malloc(str.size() + 1));
memcpy(result, str.c_str(), str.size() + 1);
return result;
}
extern "C" duckdb_value duckdb_vx_expr_bound_constant_get_value(duckdb_vx_expr ffi_expr) {
if (!ffi_expr) {
return nullptr;
}
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundConstantExpression>();
return reinterpret_cast<duckdb_value>(&expr.value);
}
extern "C" void duckdb_vx_expr_get_bound_comparison(duckdb_vx_expr ffi_expr,
duckdb_vx_expr_bound_comparison *out) {
if (!ffi_expr || !out) {
return;
}
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundComparisonExpression>();
out->left = reinterpret_cast<duckdb_vx_expr>(expr.left.get());
out->right = reinterpret_cast<duckdb_vx_expr>(expr.right.get());
out->type = static_cast<duckdb_vx_expr_type>(expr.type);
}
extern "C" void duckdb_vx_expr_get_bound_conjunction(duckdb_vx_expr ffi_expr,
duckdb_vx_expr_bound_conjunction *out) {
if (!ffi_expr || !out) {
return;
}
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundConjunctionExpression>();
out->children_count = expr.children.size();
out->children = reinterpret_cast<duckdb_vx_expr *>(expr.children.data());
out->type = static_cast<duckdb_vx_expr_type>(expr.type);
}
extern "C" void duckdb_vx_expr_get_bound_between(duckdb_vx_expr ffi_expr, duckdb_vx_expr_bound_between *out) {
if (!ffi_expr || !out) {
return;
}
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundBetweenExpression>();
out->input = reinterpret_cast<duckdb_vx_expr>(expr.input.get());
out->lower = reinterpret_cast<duckdb_vx_expr>(expr.lower.get());
out->upper = reinterpret_cast<duckdb_vx_expr>(expr.upper.get());
out->lower_inclusive = expr.lower_inclusive;
out->upper_inclusive = expr.upper_inclusive;
}
extern "C" void duckdb_vx_expr_get_bound_operator(duckdb_vx_expr ffi_expr,
duckdb_vx_expr_bound_operator *out) {
if (!ffi_expr || !out) {
return;
}
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundOperatorExpression>();
out->children_count = expr.children.size();
out->children = reinterpret_cast<duckdb_vx_expr *>(expr.children.data());
out->type = static_cast<duckdb_vx_expr_type>(expr.type);
}
extern "C" void duckdb_vx_expr_get_bound_function(duckdb_vx_expr ffi_expr,
duckdb_vx_expr_bound_function *out) {
if (!ffi_expr || !out) {
return;
}
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundFunctionExpression>();
out->children_count = expr.children.size();
out->children = reinterpret_cast<duckdb_vx_expr *>(expr.children.data());
out->scalar_function = reinterpret_cast<duckdb_vx_sfunc>(&expr.function);
out->bind_info = expr.bind_info.get();
}
extern "C" duckdb_vx_expr duckdb_vx_expr_get_bound_cast_child(duckdb_vx_expr ffi_expr) {
D_ASSERT(ffi_expr);
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundCastExpression>();
return reinterpret_cast<duckdb_vx_expr>(expr.child.get());
}
extern "C" bool duckdb_vx_expr_get_bound_cast_is_try(duckdb_vx_expr ffi_expr) {
D_ASSERT(ffi_expr);
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundCastExpression>();
return expr.try_cast;
}
extern "C" duckdb_vx_agg_func duckdb_vx_expr_get_bound_aggregate_function(duckdb_vx_expr ffi_expr) {
D_ASSERT(ffi_expr);
auto &expr = reinterpret_cast<Expression *>(ffi_expr)->Cast<BoundAggregateExpression>();
return reinterpret_cast<duckdb_vx_agg_func>(&expr.function);
}