Project
Loading...
Searching...
No Matches
Expressions.h
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11#ifndef O2_FRAMEWORK_EXPRESSIONS_H_
12#define O2_FRAMEWORK_EXPRESSIONS_H_
13
14#include "Framework/BasicOps.h"
16#include "Framework/Pack.h"
18#include "Framework/Variant.h"
22#include <arrow/type_fwd.h>
23#include <gandiva/gandiva_aliases.h>
24#include <arrow/type.h>
25#include <gandiva/arrow.h>
26#if !defined(__CLING__) && !defined(__ROOTCLING__)
27#include <arrow/table.h>
28#include <gandiva/selection_vector.h>
29#include <gandiva/node.h>
30#include <gandiva/filter.h>
31#include <gandiva/projector.h>
32#else
33namespace gandiva
34{
35class SelectionVector;
36class Filter;
37class Projector;
38} // namespace gandiva
39#endif
40#include <variant>
41#include <string>
42#include <memory>
43#include <set>
44#include <stack>
45namespace gandiva
46{
47using Selection = std::shared_ptr<gandiva::SelectionVector>;
48using FilterPtr = std::shared_ptr<gandiva::Filter>;
49} // namespace gandiva
50
51using atype = arrow::Type;
53 ExpressionInfo(int ai, size_t hash, std::set<uint32_t>&& hs, gandiva::SchemaPtr sc)
54 : argumentIndex(ai),
55 processHash(hash),
56 hashes(hs),
57 schema(sc)
58 {
59 }
62 std::set<uint32_t> hashes;
63 gandiva::SchemaPtr schema;
64 gandiva::NodePtr tree = nullptr;
67 bool resetSelection = false;
68};
69
71{
72const char* stringType(atype::type t);
73
74template <typename... T>
76 using stored_type = std::variant<T...>;
78};
79
81
82template <typename T>
83constexpr auto selectArrowType()
84{
85 return atype::NA;
86}
87
88#define SELECT_ARROW_TYPE(_Ctype_, _Atype_) \
89 template <typename T> \
90 requires std::same_as<T, _Ctype_> \
91 constexpr auto selectArrowType() \
92 { \
93 return atype::_Atype_; \
94 }
95
97SELECT_ARROW_TYPE(float, FLOAT);
98SELECT_ARROW_TYPE(double, DOUBLE);
99SELECT_ARROW_TYPE(uint8_t, UINT8);
100SELECT_ARROW_TYPE(int8_t, INT8);
101SELECT_ARROW_TYPE(uint16_t, UINT16);
102SELECT_ARROW_TYPE(int16_t, INT16);
103SELECT_ARROW_TYPE(uint32_t, UINT32);
104SELECT_ARROW_TYPE(int32_t, INT32);
105SELECT_ARROW_TYPE(uint64_t, UINT64);
106SELECT_ARROW_TYPE(int64_t, INT64);
107
108std::shared_ptr<arrow::DataType> concreteArrowType(atype::type type);
109std::string upcastTo(atype::type f);
110
113 template <typename T>
115 {
116 }
117
118 LiteralNode(LiteralNode const& other) = default;
119
122 atype::type type = atype::NA;
123};
124
127 BindingNode(BindingNode const&) = default;
129 constexpr BindingNode(const char* name_, uint32_t hash_, atype::type type_) : name{name_}, hash{hash_}, type{type_} {}
130 const char* name;
131 uint32_t hash;
132 atype::type type;
133};
134
136struct OpNode {
137 OpNode(BasicOp op_) : op{op_} {}
138 OpNode(OpNode const& other) = default;
140};
141
144 template <typename T>
146 {
147 if constexpr (variant_trait_v<typename std::decay<T>::type> != VariantType::Unknown) {
148 retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{context.options().get<T>(name)}; };
149 } else {
150 runtime_error("Unknown parameter used in expression.");
151 }
152 }
153
155
156 void reset(InitContext& context)
157 {
158 value = retrieve(context, name.data());
159 }
160
161 std::string const& name;
163};
164
167 ParameterNode(int index_ = -1)
168 : LiteralNode((float)0),
169 index{index_}
170 {
171 }
172
173 ParameterNode(ParameterNode const&) = default;
174
175 template <typename T>
176 void reset(T value_, int index_ = -1)
177 {
178 (*static_cast<LiteralNode*>(this)) = LiteralNode(value_);
179 if (index_ > 0) {
180 index = index_;
181 }
182 }
183
184 int index;
185};
186
189};
190
192struct Node {
193 Node(LiteralNode&& v) : self{std::forward<LiteralNode>(v)}, left{nullptr}, right{nullptr}, condition{nullptr}
194 {
195 }
196
197 Node(PlaceholderNode&& v) : self{std::forward<PlaceholderNode>(v)}, left{nullptr}, right{nullptr}, condition{nullptr}
198 {
199 }
200
201 Node(Node&& n) : self{std::forward<self_t>(n.self)}, left{std::forward<std::unique_ptr<Node>>(n.left)}, right{std::forward<std::unique_ptr<Node>>(n.right)}, condition{std::forward<std::unique_ptr<Node>>(n.condition)}
202 {
203 }
204
205 Node(BindingNode const& n) : self{n}, left{nullptr}, right{nullptr}, condition{nullptr}
206 {
207 }
208
209 Node(ParameterNode&& p) : self{std::forward<ParameterNode>(p)}, left{nullptr}, right{nullptr}, condition{nullptr}
210 {
211 }
212
213 Node(ConditionalNode op, Node&& then_, Node&& else_, Node&& condition_)
214 : self{op},
215 left{std::make_unique<Node>(std::forward<Node>(then_))},
216 right{std::make_unique<Node>(std::forward<Node>(else_))},
217 condition{std::make_unique<Node>(std::forward<Node>(condition_))} {}
218
220 : self{op},
221 left{std::make_unique<Node>(std::forward<Node>(l))},
222 right{std::make_unique<Node>(std::forward<Node>(r))},
223 condition{nullptr} {}
224
226 : self{op},
227 left{std::make_unique<Node>(std::forward<Node>(l))},
228 right{nullptr},
229 condition{nullptr} {}
230
232 : self{other.self},
234 {
235 if (other.left != nullptr) {
236 left = std::make_unique<Node>(*other.left);
237 }
238 if (other.right != nullptr) {
239 right = std::make_unique<Node>(*other.right);
240 }
241 if (other.condition != nullptr) {
242 condition = std::make_unique<Node>(*other.condition);
243 }
244 }
245
247 using self_t = std::variant<LiteralNode, BindingNode, OpNode, PlaceholderNode, ConditionalNode, ParameterNode>;
249 size_t index = 0;
251 std::unique_ptr<Node> left = nullptr;
252 std::unique_ptr<Node> right = nullptr;
253 std::unique_ptr<Node> condition = nullptr;
254};
255
259 Node* node_ptr = nullptr;
260 size_t index = 0;
261 explicit NodeRecord(Node* node_, size_t index_) : node_ptr(node_), index{index_} {}
262 bool operator!=(NodeRecord const& rhs)
263 {
264 return this->node_ptr != rhs.node_ptr;
265 }
266};
267
269template <typename L>
270void walk(Node* head, L const& pred)
271{
272 std::stack<NodeRecord> path;
273 path.emplace(head, 0);
274 while (!path.empty()) {
275 auto& top = path.top();
276 pred(top.node_ptr);
277
278 auto* leftp = top.node_ptr->left.get();
279 auto* rightp = top.node_ptr->right.get();
280 auto* condp = top.node_ptr->condition.get();
281 path.pop();
282
283 if (leftp != nullptr) {
284 path.emplace(leftp, 0);
285 }
286 if (rightp != nullptr) {
287 path.emplace(rightp, 0);
288 }
289 if (condp != nullptr) {
290 path.emplace(condp, 0);
291 }
292 }
293}
294
296
297#define BINARY_OP_NODES(_operator_, _operation_) \
298 inline Node operator _operator_(Node&& left, Node&& right) \
299 { \
300 return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), std::forward<Node>(right)}; \
301 } \
302 template <typename T> \
303 inline Node operator _operator_(Node&& left, T right) requires(std::is_arithmetic_v<std::decay_t<T>>) \
304 { \
305 return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), LiteralNode{right}}; \
306 } \
307 template <typename T> \
308 inline Node operator _operator_(T left, Node&& right) requires(std::is_arithmetic_v<std::decay_t<T>>) \
309 { \
310 return Node{OpNode{BasicOp::_operation_}, LiteralNode{left}, std::forward<Node>(right)}; \
311 } \
312 template <typename T> \
313 inline Node operator _operator_(Node&& left, Configurable<T> const& right) \
314 { \
315 return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), PlaceholderNode{right}}; \
316 } \
317 template <typename T> \
318 inline Node operator _operator_(Configurable<T> const& left, Node&& right) \
319 { \
320 return Node{OpNode{BasicOp::_operation_}, PlaceholderNode{left}, std::forward<Node>(right)}; \
321 } \
322 inline Node operator _operator_(BindingNode const& left, BindingNode const& right) \
323 { \
324 return Node{OpNode{BasicOp::_operation_}, left, right}; \
325 } \
326 inline Node operator _operator_(BindingNode const& left, Node&& right) \
327 { \
328 return Node{OpNode{BasicOp::_operation_}, left, std::forward<Node>(right)}; \
329 } \
330 inline Node operator _operator_(Node&& left, BindingNode const& right) \
331 { \
332 return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), right}; \
333 } \
334 template <typename T> \
335 inline Node operator _operator_(Configurable<T> const& left, BindingNode const& right) \
336 { \
337 return Node{OpNode{BasicOp::_operation_}, PlaceholderNode{left}, right}; \
338 } \
339 template <typename T> \
340 inline Node operator _operator_(BindingNode const& left, Configurable<T> const& right) \
341 { \
342 return Node{OpNode{BasicOp::_operation_}, left, PlaceholderNode{right}}; \
343 }
344
360
362template <typename T>
363inline Node npow(Node&& left, T right) requires(std::is_arithmetic_v<T>)
364{
365 return Node{OpNode{BasicOp::Power}, std::forward<Node>(left), LiteralNode{right}};
366}
367
368#define BINARY_FUNC_NODES(_func_, _node_) \
369 template <typename L, typename R> \
370 inline Node _node_(L left, R right) requires(std::is_arithmetic_v<L> && std::is_arithmetic_v<R>) \
371 { \
372 return Node{OpNode{BasicOp::_func_}, LiteralNode{left}, LiteralNode{right}}; \
373 } \
374 \
375 inline Node _node_(Node&& left, Node&& right) \
376 { \
377 return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), std::forward<Node>(right)}; \
378 } \
379 \
380 inline Node _node_(Node&& left, BindingNode const& right) \
381 { \
382 return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), right}; \
383 } \
384 \
385 inline Node _node_(BindingNode const& left, BindingNode const& right) \
386 { \
387 return Node{OpNode{BasicOp::_func_}, left, right}; \
388 } \
389 \
390 inline Node _node_(BindingNode const& left, Node&& right) \
391 { \
392 return Node{OpNode{BasicOp::_func_}, left, std::forward<Node>(right)}; \
393 } \
394 \
395 template <typename T> \
396 inline Node _node_(Node&& left, Configurable<T> const& right) \
397 { \
398 return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), PlaceholderNode{right}}; \
399 } \
400 \
401 template <typename T> \
402 inline Node _node_(Configurable<T> const& left, Node&& right) \
403 { \
404 return Node{OpNode{BasicOp::_func_}, PlaceholderNode{left}, std::forward<Node>(right)}; \
405 } \
406 \
407 template <typename T> \
408 inline Node _node_(BindingNode const& left, Configurable<T> const& right) \
409 { \
410 return Node{OpNode{BasicOp::_func_}, left, PlaceholderNode{right}}; \
411 } \
412 \
413 template <typename T> \
414 inline Node _node_(Configurable<T> const& left, BindingNode const& right) \
415 { \
416 return Node{OpNode{BasicOp::_func_}, PlaceholderNode{left}, right}; \
417 }
418
420#define ncheckbit(_node_, _bit_) ((_node_ & _bit_) == _bit_)
421
423#define UNARY_FUNC_NODES(_func_, _node_) \
424 inline Node _node_(Node&& arg) \
425 { \
426 return Node{OpNode{BasicOp::_func_}, std::forward<Node>(arg)}; \
427 }
428
442
444inline Node ifnode(Node&& condition_, Node&& then_, Node&& else_)
445{
446 return Node{ConditionalNode{}, std::forward<Node>(then_), std::forward<Node>(else_), std::forward<Node>(condition_)};
447}
448
449template <typename L>
450inline Node ifnode(Node&& condition_, Node&& then_, L else_) requires(std::is_arithmetic_v<L>)
451{
452 return Node{ConditionalNode{}, std::forward<Node>(then_), LiteralNode{else_}, std::forward<Node>(condition_)};
453}
454
455template <typename L>
456inline Node ifnode(Node&& condition_, L then_, Node&& else_) requires(std::is_arithmetic_v<L>)
457{
458 return Node{ConditionalNode{}, LiteralNode{then_}, std::forward<Node>(else_), std::forward<Node>(condition_)};
459}
460
461template <typename L1, typename L2>
462inline Node ifnode(Node&& condition_, L1 then_, L2 else_) requires(std::is_arithmetic_v<L1>&& std::is_arithmetic_v<L2>)
463{
464 return Node{ConditionalNode{}, LiteralNode{then_}, LiteralNode{else_}, std::forward<Node>(condition_)};
465}
466
467template <typename T>
468inline Node ifnode(Configurable<T> const& condition_, Node&& then_, Node&& else_)
469{
470 return Node{ConditionalNode{}, std::forward<Node>(then_), std::forward<Node>(else_), PlaceholderNode{condition_}};
471}
472
473template <typename L>
474inline Node ifnode(Node&& condition_, Node&& then_, Configurable<L> const& else_)
475{
476 return Node{ConditionalNode{}, std::forward<Node>(then_), PlaceholderNode{else_}, std::forward<Node>(condition_)};
477}
478
479template <typename L>
480inline Node ifnode(Node&& condition_, Configurable<L> const& then_, Node&& else_)
481{
482 return Node{ConditionalNode{}, PlaceholderNode{then_}, std::forward<Node>(else_), std::forward<Node>(condition_)};
483}
484
485template <typename L1, typename L2>
486inline Node ifnode(Node&& condition_, Configurable<L1> const& then_, Configurable<L2> const& else_)
487{
488 return Node{ConditionalNode{}, PlaceholderNode{then_}, PlaceholderNode{else_}, std::forward<Node>(condition_)};
489}
490
492inline Node par(int index)
493{
494 return Node{ParameterNode{index}};
495}
496
498template <typename T>
499inline Node binned(std::vector<T> const& binning, std::vector<T> const& parameters, Node&& binned, Node&& pexp, Node&& out)
500{
501 int bins = binning.size() - 1;
502 const auto binned_copy = binned;
503 const auto out_copy = out;
504 auto root = ifnode(Node{binned_copy} < binning[0], Node{out_copy}, LiteralNode{-1});
505 auto* current = &root;
506 for (auto i = 0; i < bins; ++i) {
507 current->right = std::make_unique<Node>(ifnode(Node{binned_copy} < binning[i + 1], updateParameters(pexp, bins, parameters, i), LiteralNode{-1}));
508 current = current->right.get();
509 }
510 current->right = std::make_unique<Node>(out);
511 return root;
512}
513
514template <typename T>
515Node updateParameters(Node const& pexp, int bins, std::vector<T> const& parameters, int bin)
516{
517 Node result{pexp};
518 auto updateParameter = [&bins, &parameters, &bin](Node* node) {
519 if (node->self.index() == 5) {
520 auto* n = std::get_if<5>(&node->self);
521 n->reset(parameters[n->index * bins + bin]);
522 }
523 };
524 walk(&result, updateParameter);
525 return result;
526}
527
529struct Filter {
530 Filter() = default;
531
532 Filter(Node&& node_) : node{std::make_unique<Node>(std::forward<Node>(node_))}
533 {
535 }
536
537 Filter(Filter&& other) : node{std::forward<std::unique_ptr<Node>>(other.node)}
538 {
540 }
541
543 {
544 node = std::move(other.node);
545 return *this;
546 }
547
548 std::unique_ptr<Node> node = nullptr;
549
550 size_t designateSubtrees(Node* node, size_t index = 0);
551};
552
553template <typename T>
554concept is_filter = std::same_as<T, Filter>;
555
557
559gandiva::Selection createSelection(std::shared_ptr<arrow::Table> const& table, Filter const& expression);
561gandiva::Selection createSelection(std::shared_ptr<arrow::Table> const& table, std::shared_ptr<gandiva::Filter> const& gfilter);
562
564using Operations = std::vector<ColumnOperationSpec>;
565
567Operations createOperations(Filter const& expression);
568
570bool isTableCompatible(std::set<uint32_t> const& hashes, Operations const& specs);
572gandiva::NodePtr createExpressionTree(Operations const& opSpecs,
573 gandiva::SchemaPtr const& Schema);
575std::shared_ptr<gandiva::Filter> createFilter(gandiva::SchemaPtr const& Schema,
576 gandiva::ConditionPtr condition);
578std::shared_ptr<gandiva::Filter> createFilter(gandiva::SchemaPtr const& Schema,
579 Operations const& opSpecs);
581std::shared_ptr<gandiva::Projector> createProjector(gandiva::SchemaPtr const& Schema,
582 Operations const& opSpecs,
583 gandiva::FieldPtr result);
585std::shared_ptr<gandiva::Projector> createProjector(gandiva::SchemaPtr const& Schema,
586 Projector&& p,
587 gandiva::FieldPtr result);
589void updateExpressionInfos(expressions::Filter const& filter, std::vector<ExpressionInfo>& eInfos);
591gandiva::ConditionPtr makeCondition(gandiva::NodePtr node);
593gandiva::ExpressionPtr makeExpression(gandiva::NodePtr node, gandiva::FieldPtr result);
596
597template <typename... C>
598std::vector<expressions::Projector> makeProjectors(framework::pack<C...>)
599{
600 return {C::Projector()...};
601}
602
603std::shared_ptr<gandiva::Projector> createProjectorHelper(size_t nColumns, expressions::Projector* projectors,
604 std::shared_ptr<arrow::Schema> schema,
605 std::vector<std::shared_ptr<arrow::Field>> const& fields);
606
607template <typename... C>
608std::shared_ptr<gandiva::Projector> createProjectors(framework::pack<C...>, std::vector<std::shared_ptr<arrow::Field>> const& fields, gandiva::SchemaPtr schema)
609{
610 std::array<expressions::Projector, sizeof...(C)> projectors{{std::move(C::Projector())...}};
611
612 return createProjectorHelper(sizeof...(C), projectors.data(), schema, fields);
613}
614
615void updateFilterInfo(ExpressionInfo& info, std::shared_ptr<arrow::Table>& table);
616} // namespace o2::framework::expressions
617
618#endif // O2_FRAMEWORK_EXPRESSIONS_H_
const auto bins
Definition PID.cxx:49
#define SELECT_ARROW_TYPE(_Ctype_, _Atype_)
Definition Expressions.h:88
#define BINARY_FUNC_NODES(_func_, _node_)
arrow::Type atype
Definition Expressions.h:51
#define UNARY_FUNC_NODES(_func_, _node_)
unary functions on nodes
int32_t i
uint32_t op
uint32_t gfilter
Definition RawData.h:6
ConfigParamRegistry const & options()
Definition InitContext.h:33
GLdouble n
Definition glcorearb.h:1982
GLuint64EXT * result
Definition glcorearb.h:5662
const GLdouble * v
Definition glcorearb.h:832
GLuint index
Definition glcorearb.h:781
GLdouble GLdouble GLdouble GLdouble top
Definition glcorearb.h:4077
GLuint const GLchar * name
Definition glcorearb.h:781
GLdouble GLdouble right
Definition glcorearb.h:4077
GLdouble f
Definition glcorearb.h:310
GLsizei const GLfloat * value
Definition glcorearb.h:819
GLint GLint GLsizei GLint GLenum GLenum type
Definition glcorearb.h:275
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition glcorearb.h:1308
GLsizei const GLchar *const * path
Definition glcorearb.h:3591
GLboolean r
Definition glcorearb.h:1233
std::shared_ptr< gandiva::Filter > FilterPtr
Definition Expressions.h:48
std::shared_ptr< gandiva::SelectionVector > Selection
Definition Expressions.h:47
std::shared_ptr< arrow::DataType > concreteArrowType(atype::type type)
std::shared_ptr< gandiva::Filter > createFilter(gandiva::SchemaPtr const &Schema, gandiva::ConditionPtr condition)
Function to create gandiva filter from gandiva condition.
gandiva::ExpressionPtr makeExpression(gandiva::NodePtr node, gandiva::FieldPtr result)
Function to create gandiva projecting expression from generic gandiva expression tree.
BINARY_OP_NODES && LogicalAnd
BINARY_OP_NODES & BitwiseAnd
std::shared_ptr< gandiva::Projector > createProjectorHelper(size_t nColumns, expressions::Projector *projectors, std::shared_ptr< arrow::Schema > schema, std::vector< std::shared_ptr< arrow::Field > > const &fields)
gandiva::Selection createSelection(std::shared_ptr< arrow::Table > const &table, Filter const &expression)
Function for creating gandiva selection from our internal filter tree.
const char * stringType(atype::type t)
std::vector< ColumnOperationSpec > Operations
void updateExpressionInfos(expressions::Filter const &filter, std::vector< ExpressionInfo > &eInfos)
Function for attaching gandiva filters to to compatible task inputs.
constexpr auto selectArrowType()
Definition Expressions.h:83
Node par(int index)
Parameters.
Operations createOperations(Filter const &expression)
Function to create an internal operation sequence from a filter tree.
Node updateParameters(Node const &pexp, int bins, std::vector< T > const &parameters, int bin)
gandiva::ConditionPtr makeCondition(gandiva::NodePtr node)
Function to create gandiva condition expression from generic gandiva expression tree.
bool isTableCompatible(std::set< uint32_t > const &hashes, Operations const &specs)
Function to check compatibility of a given arrow schema with operation sequence.
Node ifnode(Node &&condition_, Node &&then_, Node &&else_)
conditionals
gandiva::NodePtr createExpressionTree(Operations const &opSpecs, gandiva::SchemaPtr const &Schema)
Function to create gandiva expression tree from operation sequence.
Node binned(std::vector< T > const &binning, std::vector< T > const &parameters, Node &&binned, Node &&pexp, Node &&out)
binned functional
void updatePlaceholders(Filter &filter, InitContext &context)
Update placeholder nodes from context.
BINARY_OP_NODES^ BitwiseXor
BINARY_OP_NODES * Multiplication
Node npow(Node &&left, T right)
functions
std::string upcastTo(atype::type f)
std::shared_ptr< gandiva::Projector > createProjector(gandiva::SchemaPtr const &Schema, Operations const &opSpecs, gandiva::FieldPtr result)
Function to create gandiva projector from operation sequence.
std::vector< expressions::Projector > makeProjectors(framework::pack< C... >)
std::shared_ptr< gandiva::Projector > createProjectors(framework::pack< C... >, std::vector< std::shared_ptr< arrow::Field > > const &fields, gandiva::SchemaPtr schema)
void updateFilterInfo(ExpressionInfo &info, std::shared_ptr< arrow::Table > &table)
void walk(Node *head, L const &pred)
Tree-walker helper.
RuntimeErrorRef runtime_error(const char *)
@ GreaterThanOrEqual
Definition BasicOps.h:29
std::vector< int64_t > SelectionVector
Definition ASoA.h:411
Defining DataPointCompositeObject explicitly as copiable.
gandiva::Selection selection
Definition Expressions.h:66
gandiva::SchemaPtr schema
Definition Expressions.h:63
ExpressionInfo(int ai, size_t hash, std::set< uint32_t > &&hs, gandiva::SchemaPtr sc)
Definition Expressions.h:53
std::set< uint32_t > hashes
Definition Expressions.h:62
gandiva::NodePtr tree
Definition Expressions.h:64
size_t processHash
Definition Expressions.h:61
An expression tree node corresponding to a column binding.
constexpr BindingNode(const char *name_, uint32_t hash_, atype::type type_)
BindingNode(BindingNode const &)=default
A struct, containing the root of the expression tree.
Filter & operator=(Filter &&other) noexcept
size_t designateSubtrees(Node *node, size_t index=0)
std::unique_ptr< Node > node
An expression tree node corresponding to a literal value.
LiteralValue::stored_type var_t
LiteralNode(LiteralNode const &other)=default
helper struct used to parse trees
bool operator!=(NodeRecord const &rhs)
Node * node_ptr
pointer to the actual tree node
NodeRecord(Node *node_, size_t index_)
std::unique_ptr< Node > condition
std::unique_ptr< Node > right
std::variant< LiteralNode, BindingNode, OpNode, PlaceholderNode, ConditionalNode, ParameterNode > self_t
variant with possible nodes
Node(BindingNode const &n)
Node(OpNode op, Node &&l, Node &&r)
Node(ConditionalNode op, Node &&then_, Node &&else_, Node &&condition_)
An expression tree node corresponding to binary or unary operation.
OpNode(OpNode const &other)=default
A placeholder node for parameters taken from an array.
ParameterNode(ParameterNode const &)=default
void reset(T value_, int index_=-1)
A placeholder node for simple type configurable.
LiteralNode::var_t(* retrieve)(InitContext &, char const *)
PlaceholderNode(PlaceholderNode const &other)=default
PlaceholderNode(Configurable< T > const &v)
VectorOfTObjectPtrs other