OmniSciDB  1dac507f6e
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter Class Reference
+ Collaboration diagram for anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter:

Classes

struct  ColNames
 

Public Member Functions

 CalciteAdapter (const Catalog_Namespace::Catalog &cat, const rapidjson::Value &rels)
 
 CalciteAdapter (const CalciteAdapter &)=delete
 
CalciteAdapteroperator= (const CalciteAdapter &)=delete
 
std::shared_ptr< Analyzer::ExprgetExprFromNode (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::pair< std::shared_ptr
< Analyzer::Expr >
, SQLQualifier
getQuantifiedRhs (const rapidjson::Value &rhs_op, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateOp (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateUnaryOp (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateLike (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets, const bool is_ilike)
 
std::shared_ptr< Analyzer::ExprtranslateRegexp (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateLikely (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateUnlikely (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateCase (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateItem (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateNow ()
 
std::shared_ptr< Analyzer::ExprtranslateExtract (const rapidjson::Value &operands, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets, const bool is_date_trunc)
 
std::shared_ptr< Analyzer::ExprtranslateDateadd (const rapidjson::Value &operands, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateDatediff (const rapidjson::Value &operands, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateDatepart (const rapidjson::Value &operands, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateColRef (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateAggregate (const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
 
std::shared_ptr< Analyzer::ExprtranslateTypedLiteral (const rapidjson::Value &expr)
 
std::list< int > getUsedColumnList (const int32_t table_id) const
 
std::vector< const
TableDescriptor * > 
getTableDescriptors () const
 

Private Member Functions

const TableDescriptorgetTableFromScanNode (const rapidjson::Value &scan_ra) const
 

Static Private Member Functions

static std::vector< std::string > getColNames (const rapidjson::Value &scan_ra)
 

Private Attributes

std::unordered_map< int32_t,
std::set< int > > 
used_columns_
 
const Catalog_Namespace::Catalogcat_
 
time_t now_
 
std::vector< ColNamescol_names_
 

Detailed Description

Definition at line 91 of file CalciteAdapter.cpp.

Constructor & Destructor Documentation

anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::CalciteAdapter ( const Catalog_Namespace::Catalog cat,
const rapidjson::Value &  rels 
)
inline

Definition at line 93 of file CalciteAdapter.cpp.

References CHECK().

94  : cat_(cat) {
95  time(&now_);
96  CHECK(rels.IsArray());
97  for (auto rels_it = rels.Begin(); rels_it != rels.End(); ++rels_it) {
98  const auto& scan_ra = *rels_it;
99  CHECK(scan_ra.IsObject());
100  if (scan_ra["relOp"].GetString() != std::string("EnumerableTableScan")) {
101  break;
102  }
103  col_names_.emplace_back(
104  ColNames{getColNames(scan_ra), getTableFromScanNode(scan_ra)});
105  }
106  }
CHECK(cgen_state)
static std::vector< std::string > getColNames(const rapidjson::Value &scan_ra)
const TableDescriptor * getTableFromScanNode(const rapidjson::Value &scan_ra) const

+ Here is the call graph for this function:

anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::CalciteAdapter ( const CalciteAdapter )
delete

Member Function Documentation

static std::vector<std::string> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getColNames ( const rapidjson::Value &  scan_ra)
inlinestaticprivate

Definition at line 595 of file CalciteAdapter.cpp.

References CHECK(), and run_benchmark_import::result.

595  {
596  CHECK(scan_ra.IsObject() && scan_ra.HasMember("fieldNames"));
597  const auto& col_names_node = scan_ra["fieldNames"];
598  CHECK(col_names_node.IsArray());
599  std::vector<std::string> result;
600  for (auto field_it = col_names_node.Begin(); field_it != col_names_node.End();
601  ++field_it) {
602  CHECK(field_it->IsString());
603  result.emplace_back(field_it->GetString());
604  }
605  return result;
606  }
CHECK(cgen_state)

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getExprFromNode ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 112 of file CalciteAdapter.cpp.

Referenced by anonymous_namespace{CalciteAdapter.cpp}::build_result_plan_targets(), anonymous_namespace{CalciteAdapter.cpp}::get_input_targets(), and anonymous_namespace{CalciteAdapter.cpp}::handle_logical_aggregate().

114  {
115  if (expr.IsObject() && expr.HasMember("op")) {
116  return translateOp(expr, scan_targets);
117  }
118  if (expr.IsObject() && expr.HasMember("input")) {
119  return translateColRef(expr, scan_targets);
120  }
121  if (expr.IsObject() && expr.HasMember("agg")) {
122  return translateAggregate(expr, scan_targets);
123  }
124  if (expr.IsObject() && expr.HasMember("literal")) {
125  return translateTypedLiteral(expr);
126  }
127  throw std::runtime_error("Unsupported node type");
128  }
std::shared_ptr< Analyzer::Expr > translateOp(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
std::shared_ptr< Analyzer::Expr > translateAggregate(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
std::shared_ptr< Analyzer::Expr > translateTypedLiteral(const rapidjson::Value &expr)
std::shared_ptr< Analyzer::Expr > translateColRef(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)

+ Here is the caller graph for this function:

std::pair<std::shared_ptr<Analyzer::Expr>, SQLQualifier> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getQuantifiedRhs ( const rapidjson::Value &  rhs_op,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 130 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, kALL, kANY, and kONE.

132  {
133  std::shared_ptr<Analyzer::Expr> rhs;
134  SQLQualifier sql_qual{kONE};
135  const auto rhs_op_it = rhs_op.FindMember("op");
136  if (rhs_op_it == rhs_op.MemberEnd()) {
137  return std::make_pair(rhs, sql_qual);
138  }
139  CHECK(rhs_op_it->value.IsString());
140  const auto& qual_str = rhs_op_it->value.GetString();
141  const auto rhs_op_operands_it = rhs_op.FindMember("operands");
142  CHECK(rhs_op_operands_it != rhs_op.MemberEnd());
143  const auto& rhs_op_operands = rhs_op_operands_it->value;
144  CHECK(rhs_op_operands.IsArray());
145  if (qual_str == std::string("PG_ANY") || qual_str == std::string("PG_ALL")) {
146  CHECK_EQ(unsigned(1), rhs_op_operands.Size());
147  rhs = getExprFromNode(rhs_op_operands[0], scan_targets);
148  sql_qual = qual_str == std::string("PG_ANY") ? kANY : kALL;
149  }
150  if (!rhs && qual_str == std::string("CAST")) {
151  CHECK_EQ(unsigned(1), rhs_op_operands.Size());
152  std::tie(rhs, sql_qual) = getQuantifiedRhs(rhs_op_operands[0], scan_targets);
153  }
154  return std::make_pair(rhs, sql_qual);
155  }
Definition: sqldefs.h:69
#define CHECK_EQ(x, y)
Definition: Logger.h:198
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
SQLQualifier
Definition: sqldefs.h:69
CHECK(cgen_state)
std::pair< std::shared_ptr< Analyzer::Expr >, SQLQualifier > getQuantifiedRhs(const rapidjson::Value &rhs_op, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
Definition: sqldefs.h:69
Definition: sqldefs.h:69

+ Here is the call graph for this function:

std::vector<const TableDescriptor*> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getTableDescriptors ( ) const
inline

Definition at line 586 of file CalciteAdapter.cpp.

586  {
587  std::vector<const TableDescriptor*> tds;
588  for (const auto& col_name_td : col_names_) {
589  tds.push_back(col_name_td.td_);
590  }
591  return tds;
592  }
const TableDescriptor* anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getTableFromScanNode ( const rapidjson::Value &  scan_ra) const
inlineprivate

Definition at line 608 of file CalciteAdapter.cpp.

References CHECK(), and CHECK_EQ.

608  {
609  const auto& table_info = scan_ra["table"];
610  CHECK(table_info.IsArray());
611  CHECK_EQ(unsigned(3), table_info.Size());
612  const auto td = cat_.getMetadataForTable(table_info[2].GetString());
613  CHECK(td);
614  return td;
615  }
#define CHECK_EQ(x, y)
Definition: Logger.h:198
CHECK(cgen_state)
const TableDescriptor * getMetadataForTable(const std::string &tableName, const bool populateFragmenter=true) const
Returns a pointer to a const TableDescriptor struct matching the provided tableName.

+ Here is the call graph for this function:

std::list<int> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getUsedColumnList ( const int32_t  table_id) const
inline

Definition at line 574 of file CalciteAdapter.cpp.

Referenced by anonymous_namespace{CalciteAdapter.cpp}::get_scan_plan().

574  {
575  std::list<int> used_column_list;
576  const auto it = used_columns_.find(table_id);
577  if (it == used_columns_.end()) {
578  return {};
579  }
580  for (const int used_col : it->second) {
581  used_column_list.push_back(used_col);
582  }
583  return used_column_list;
584  }
std::unordered_map< int32_t, std::set< int > > used_columns_

+ Here is the caller graph for this function:

CalciteAdapter& anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::operator= ( const CalciteAdapter )
delete
std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateAggregate ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 487 of file CalciteAdapter.cpp.

References CHECK(), CHECK_LT, anonymous_namespace{CalciteAdapter.cpp}::get_agg_operand_idx(), get_agg_type(), anonymous_namespace{RelAlgOptimizer.cpp}::is_distinct(), ThriftSerializers::takes_arg(), and to_agg_kind().

489  {
490  CHECK(expr.IsObject() && expr.HasMember("type"));
491  const auto& expr_type = expr["type"];
492  CHECK(expr_type.IsObject());
493  const auto agg_kind = to_agg_kind(expr["agg"].GetString());
494  const bool is_distinct = expr["distinct"].GetBool();
495  const auto operand = get_agg_operand_idx(expr);
496  const bool takes_arg{operand >= 0};
497  if (takes_arg) {
498  CHECK_LT(operand, static_cast<ssize_t>(scan_targets.size()));
499  }
500  const auto arg_expr = takes_arg ? scan_targets[operand]->get_own_expr() : nullptr;
501  const auto agg_ti = get_agg_type(agg_kind, arg_expr.get());
502  return makeExpr<Analyzer::AggExpr>(agg_ti, agg_kind, arg_expr, is_distinct, nullptr);
503  }
SQLAgg to_agg_kind(const std::string &agg_name)
SQLTypeInfo get_agg_type(const SQLAgg agg_kind, const Analyzer::Expr *arg_expr)
CHECK(cgen_state)
ssize_t get_agg_operand_idx(const rapidjson::Value &expr)
#define CHECK_LT(x, y)
Definition: Logger.h:200
bool takes_arg(const TargetInfo &target_info)
bool is_distinct(const size_t input_idx, const RelAlgNode *node)

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateCase ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 344 of file CalciteAdapter.cpp.

References CHECK_GE, and Parser::CaseExpr::normalize().

346  {
347  const auto& operands = expr["operands"];
348  CHECK_GE(operands.Size(), unsigned(2));
349  std::shared_ptr<Analyzer::Expr> else_expr;
350  std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
351  expr_list;
352  for (auto operands_it = operands.Begin(); operands_it != operands.End();) {
353  const auto when_expr = getExprFromNode(*operands_it++, scan_targets);
354  if (operands_it == operands.End()) {
355  else_expr = when_expr;
356  break;
357  }
358  const auto then_expr = getExprFromNode(*operands_it++, scan_targets);
359  expr_list.emplace_back(when_expr, then_expr);
360  }
361  return Parser::CaseExpr::normalize(expr_list, else_expr);
362  }
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
#define CHECK_GE(x, y)
Definition: Logger.h:203
static std::shared_ptr< Analyzer::Expr > normalize(const std::list< std::pair< std::shared_ptr< Analyzer::Expr >, std::shared_ptr< Analyzer::Expr >>> &, const std::shared_ptr< Analyzer::Expr >)
Definition: ParserNode.cpp:905

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateColRef ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 458 of file CalciteAdapter.cpp.

References CHECK(), and CHECK_GE.

460  {
461  int col_name_idx = expr["input"].GetInt();
462  CHECK_GE(col_name_idx, 0);
463  if (static_cast<size_t>(col_name_idx) < scan_targets.size()) {
464  auto var_expr = std::dynamic_pointer_cast<Analyzer::Var>(
465  scan_targets[col_name_idx]->get_own_expr());
466  if (var_expr) {
467  return var_expr;
468  }
469  }
470  int rte_idx{0};
471  for (const auto& col_name_td : col_names_) {
472  if (static_cast<size_t>(col_name_idx) < col_name_td.names_.size()) {
473  const auto& col_name = col_name_td.names_[col_name_idx];
474  const auto cd = cat_.getMetadataForColumn(col_name_td.td_->tableId, col_name);
475  CHECK(cd);
476  used_columns_[col_name_td.td_->tableId].insert(cd->columnId);
477  return makeExpr<Analyzer::ColumnVar>(
478  cd->columnType, col_name_td.td_->tableId, cd->columnId, rte_idx);
479  }
480  col_name_idx -= col_name_td.names_.size();
481  ++rte_idx;
482  }
483  CHECK(false);
484  return nullptr;
485  }
#define CHECK_GE(x, y)
Definition: Logger.h:203
CHECK(cgen_state)
const ColumnDescriptor * getMetadataForColumn(int tableId, const std::string &colName) const
std::unordered_map< int32_t, std::set< int > > used_columns_

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateDateadd ( const rapidjson::Value &  operands,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 402 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, kTIMESTAMP, and to_dateadd_field().

404  {
405  CHECK(operands.IsArray());
406  CHECK_EQ(unsigned(3), operands.Size());
407  const auto& timeunit_lit = operands[0];
408  if (!timeunit_lit.IsObject() || !timeunit_lit.HasMember("literal")) {
409  throw std::runtime_error("The time unit parameter must be a literal.");
410  }
411  const auto timeunit_lit_expr = std::dynamic_pointer_cast<const Analyzer::Constant>(
412  translateTypedLiteral(timeunit_lit));
413  const auto number_units = getExprFromNode(operands[1], scan_targets);
414  const auto datetime = getExprFromNode(operands[2], scan_targets);
415  return makeExpr<Analyzer::DateaddExpr>(
416  SQLTypeInfo(kTIMESTAMP, false),
417  to_dateadd_field(*timeunit_lit_expr->get_constval().stringval),
418  number_units,
419  datetime);
420  }
#define CHECK_EQ(x, y)
Definition: Logger.h:198
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
CHECK(cgen_state)
SQLTypeInfoCore< ArrayContextTypeSizer, ExecutorTypePackaging, DateTimeFacilities > SQLTypeInfo
Definition: sqltypes.h:852
std::shared_ptr< Analyzer::Expr > translateTypedLiteral(const rapidjson::Value &expr)
DateaddField to_dateadd_field(const std::string &field)

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateDatediff ( const rapidjson::Value &  operands,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 422 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, kBIGINT, and to_datediff_field().

424  {
425  CHECK(operands.IsArray());
426  CHECK_EQ(unsigned(3), operands.Size());
427  const auto& timeunit_lit = operands[0];
428  if (!timeunit_lit.IsObject() || !timeunit_lit.HasMember("literal")) {
429  throw std::runtime_error("The time unit parameter must be a literal.");
430  }
431  const auto timeunit_lit_expr = std::dynamic_pointer_cast<const Analyzer::Constant>(
432  translateTypedLiteral(timeunit_lit));
433  const auto start = getExprFromNode(operands[1], scan_targets);
434  const auto end = getExprFromNode(operands[2], scan_targets);
435  return makeExpr<Analyzer::DatediffExpr>(
436  SQLTypeInfo(kBIGINT, false),
437  to_datediff_field(*timeunit_lit_expr->get_constval().stringval),
438  start,
439  end);
440  }
#define CHECK_EQ(x, y)
Definition: Logger.h:198
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
CHECK(cgen_state)
DatetruncField to_datediff_field(const std::string &field)
SQLTypeInfoCore< ArrayContextTypeSizer, ExecutorTypePackaging, DateTimeFacilities > SQLTypeInfo
Definition: sqltypes.h:852
std::shared_ptr< Analyzer::Expr > translateTypedLiteral(const rapidjson::Value &expr)

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateDatepart ( const rapidjson::Value &  operands,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 442 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, ExtractExpr::generate(), and to_datepart_field().

444  {
445  CHECK(operands.IsArray());
446  CHECK_EQ(unsigned(2), operands.Size());
447  const auto& timeunit_lit = operands[0];
448  if (!timeunit_lit.IsObject() || !timeunit_lit.HasMember("literal")) {
449  throw std::runtime_error("The time unit parameter must be a literal.");
450  }
451  const auto timeunit_lit_expr = std::dynamic_pointer_cast<const Analyzer::Constant>(
452  translateTypedLiteral(timeunit_lit));
453  const auto from_expr = getExprFromNode(operands[1], scan_targets);
454  return ExtractExpr::generate(
455  from_expr, to_datepart_field(*timeunit_lit_expr->get_constval().stringval));
456  }
#define CHECK_EQ(x, y)
Definition: Logger.h:198
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
ExtractField to_datepart_field(const std::string &field)
CHECK(cgen_state)
const std::shared_ptr< Analyzer::Expr > generate() const
std::shared_ptr< Analyzer::Expr > translateTypedLiteral(const rapidjson::Value &expr)

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateExtract ( const rapidjson::Value &  operands,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets,
const bool  is_date_trunc 
)
inline

Definition at line 380 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, ExtractExpr::generate(), and DateTruncExpr::generate().

383  {
384  CHECK(operands.IsArray());
385  CHECK_EQ(unsigned(2), operands.Size());
386  const auto& timeunit_lit = operands[0];
387  if (!timeunit_lit.IsObject() || !timeunit_lit.HasMember("literal")) {
388  throw std::runtime_error("The time unit parameter must be a literal.");
389  }
390  const auto timeunit_lit_expr = std::dynamic_pointer_cast<const Analyzer::Constant>(
391  translateTypedLiteral(timeunit_lit));
392  const auto from_expr = getExprFromNode(operands[1], scan_targets);
393  if (is_date_trunc) {
394  return DateTruncExpr::generate(from_expr,
395  *timeunit_lit_expr->get_constval().stringval);
396  } else {
397  return ExtractExpr::generate(from_expr,
398  *timeunit_lit_expr->get_constval().stringval);
399  }
400  }
#define CHECK_EQ(x, y)
Definition: Logger.h:198
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
CHECK(cgen_state)
const std::shared_ptr< Analyzer::Expr > generate() const
std::shared_ptr< Analyzer::Expr > translateTypedLiteral(const rapidjson::Value &expr)
const std::shared_ptr< Analyzer::Expr > generate() const

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateItem ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 364 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, kARRAY_AT, and kONE.

366  {
367  const auto& operands = expr["operands"];
368  CHECK(operands.IsArray());
369  CHECK_EQ(operands.Size(), unsigned(2));
370  auto base = getExprFromNode(operands[0], scan_targets);
371  auto index = getExprFromNode(operands[1], scan_targets);
372  return makeExpr<Analyzer::BinOper>(
373  base->get_type_info().get_elem_type(), false, kARRAY_AT, kONE, base, index);
374  }
#define CHECK_EQ(x, y)
Definition: Logger.h:198
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
CHECK(cgen_state)
Definition: sqldefs.h:69

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateLike ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets,
const bool  is_ilike 
)
inline

Definition at line 303 of file CalciteAdapter.cpp.

References CHECK_GE, and Parser::LikeExpr::get().

306  {
307  const auto& operands = expr["operands"];
308  CHECK_GE(operands.Size(), unsigned(2));
309  auto lhs = getExprFromNode(operands[0], scan_targets);
310  auto rhs = getExprFromNode(operands[1], scan_targets);
311  auto esc = operands.Size() > 2 ? getExprFromNode(operands[2], scan_targets) : nullptr;
312  return Parser::LikeExpr::get(lhs, rhs, esc, is_ilike, false);
313  }
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
#define CHECK_GE(x, y)
Definition: Logger.h:203
const int32_t groups_buffer_size return nullptr
static std::shared_ptr< Analyzer::Expr > get(std::shared_ptr< Analyzer::Expr > arg_expr, std::shared_ptr< Analyzer::Expr > like_expr, std::shared_ptr< Analyzer::Expr > escape_expr, const bool is_ilike, const bool is_not)
Definition: ParserNode.cpp:530

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateLikely ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 326 of file CalciteAdapter.cpp.

References CHECK_GE, and Parser::LikelihoodExpr::get().

328  {
329  const auto& operands = expr["operands"];
330  CHECK_GE(operands.Size(), unsigned(1));
331  auto arg = getExprFromNode(operands[0], scan_targets);
332  return Parser::LikelihoodExpr::get(arg, 0.9375, false);
333  }
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
#define CHECK_GE(x, y)
Definition: Logger.h:203
static std::shared_ptr< Analyzer::Expr > get(std::shared_ptr< Analyzer::Expr > arg_expr, float likelihood, const bool is_not)
Definition: ParserNode.cpp:676

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateNow ( )
inline

Definition at line 376 of file CalciteAdapter.cpp.

References Parser::TimestampLiteral::get().

376  {
378  }
static std::shared_ptr< Analyzer::Expr > get(const int64_t)
Definition: ParserNode.cpp:173

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateOp ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 157 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, CHECK_GE, kFUNCTION, kONE, Parser::OperExpr::normalize(), and to_sql_op().

159  {
160  const auto op_str = expr["op"].GetString();
161  if (op_str == std::string("LIKE") || op_str == std::string("PG_ILIKE")) {
162  return translateLike(expr, scan_targets, op_str == std::string("PG_ILIKE"));
163  }
164  if (op_str == std::string("REGEXP_LIKE")) {
165  return translateRegexp(expr, scan_targets);
166  }
167  if (op_str == std::string("LIKELY")) {
168  return translateLikely(expr, scan_targets);
169  }
170  if (op_str == std::string("UNLIKELY")) {
171  return translateUnlikely(expr, scan_targets);
172  }
173  if (op_str == std::string("CASE")) {
174  return translateCase(expr, scan_targets);
175  }
176  if (op_str == std::string("ITEM")) {
177  return translateItem(expr, scan_targets);
178  }
179  const auto& operands = expr["operands"];
180  CHECK(operands.IsArray());
181  if (op_str == std::string("NOW")) {
182  CHECK_EQ(unsigned(0), operands.Size());
183  return translateNow();
184  }
185  if (op_str == std::string("DATETIME")) {
186  CHECK_EQ(unsigned(1), operands.Size());
187  const auto& now_lit = operands[0];
188  const std::string datetime_err{R"(Only DATETIME('NOW') supported for now.)"};
189  if (!now_lit.IsObject() || !now_lit.HasMember("literal")) {
190  throw std::runtime_error(datetime_err);
191  }
192  const auto now_lit_expr = std::dynamic_pointer_cast<const Analyzer::Constant>(
193  translateTypedLiteral(now_lit));
194  CHECK(now_lit_expr);
195  CHECK(now_lit_expr->get_type_info().is_string());
196  if (*now_lit_expr->get_constval().stringval != std::string("NOW")) {
197  throw std::runtime_error(datetime_err);
198  }
199  return translateNow();
200  }
201  if (op_str == std::string("PG_EXTRACT") || op_str == std::string("PG_DATE_TRUNC")) {
202  return translateExtract(
203  operands, scan_targets, op_str == std::string("PG_DATE_TRUNC"));
204  }
205  if (op_str == std::string("DATEADD")) {
206  return translateDateadd(operands, scan_targets);
207  }
208  if (op_str == std::string("DATEDIFF")) {
209  return translateDatediff(operands, scan_targets);
210  }
211  if (op_str == std::string("DATEPART")) {
212  return translateDatepart(operands, scan_targets);
213  }
214  if (op_str == std::string("LENGTH") || op_str == std::string("CHAR_LENGTH")) {
215  CHECK_EQ(unsigned(1), operands.Size());
216  auto str_arg = getExprFromNode(operands[0], scan_targets);
217  return makeExpr<Analyzer::CharLengthExpr>(str_arg->decompress(),
218  op_str == std::string("CHAR_LENGTH"));
219  }
220  if (op_str == std::string("KEY_FOR_STRING")) {
221  CHECK_EQ(unsigned(1), operands.Size());
222  auto str_arg = getExprFromNode(operands[0], scan_targets);
223  return makeExpr<Analyzer::KeyForStringExpr>(str_arg);
224  }
225  if (op_str == std::string("CARDINALITY") || op_str == std::string("ARRAY_LENGTH")) {
226  CHECK_EQ(unsigned(1), operands.Size());
227  auto str_arg = getExprFromNode(operands[0], scan_targets);
228  return makeExpr<Analyzer::CardinalityExpr>(str_arg->decompress());
229  }
230  if (op_str == std::string("$SCALAR_QUERY")) {
231  throw std::runtime_error("Subqueries not supported");
232  }
233  if (operands.Size() == 1) {
234  return translateUnaryOp(expr, scan_targets);
235  }
236  CHECK_GE(operands.Size(), unsigned(2));
237  auto lhs = getExprFromNode(operands[0], scan_targets);
238  for (size_t i = 1; i < operands.Size(); ++i) {
239  std::shared_ptr<Analyzer::Expr> rhs;
240  SQLQualifier sql_qual{kONE};
241  const auto& rhs_op = operands[i];
242  std::tie(rhs, sql_qual) = getQuantifiedRhs(rhs_op, scan_targets);
243  if (!rhs) {
244  rhs = getExprFromNode(rhs_op, scan_targets);
245  }
246  CHECK(rhs);
247  const auto sql_op = to_sql_op(op_str);
248  if (sql_op == kFUNCTION) {
249  throw std::runtime_error(std::string("Unsupported operator: ") + op_str);
250  }
251  lhs = Parser::OperExpr::normalize(sql_op, sql_qual, lhs, rhs);
252  }
253  return lhs;
254  }
#define CHECK_EQ(x, y)
Definition: Logger.h:198
std::shared_ptr< Analyzer::Expr > translateRegexp(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
std::shared_ptr< Analyzer::Expr > translateDatepart(const rapidjson::Value &operands, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
SQLQualifier
Definition: sqldefs.h:69
std::shared_ptr< Analyzer::Expr > translateDatediff(const rapidjson::Value &operands, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
#define CHECK_GE(x, y)
Definition: Logger.h:203
std::shared_ptr< Analyzer::Expr > translateLike(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets, const bool is_ilike)
std::shared_ptr< Analyzer::Expr > translateItem(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
std::shared_ptr< Analyzer::Expr > translateExtract(const rapidjson::Value &operands, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets, const bool is_date_trunc)
std::shared_ptr< Analyzer::Expr > translateCase(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
CHECK(cgen_state)
std::pair< std::shared_ptr< Analyzer::Expr >, SQLQualifier > getQuantifiedRhs(const rapidjson::Value &rhs_op, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
SQLOps to_sql_op(const std::string &op_str)
std::shared_ptr< Analyzer::Expr > translateUnaryOp(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
static std::shared_ptr< Analyzer::Expr > normalize(const SQLOps optype, const SQLQualifier qual, std::shared_ptr< Analyzer::Expr > left_expr, std::shared_ptr< Analyzer::Expr > right_expr)
Definition: ParserNode.cpp:261
Definition: sqldefs.h:69
std::shared_ptr< Analyzer::Expr > translateTypedLiteral(const rapidjson::Value &expr)
std::shared_ptr< Analyzer::Expr > translateLikely(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
std::shared_ptr< Analyzer::Expr > translateUnlikely(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
std::shared_ptr< Analyzer::Expr > translateDateadd(const rapidjson::Value &operands, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateRegexp ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 315 of file CalciteAdapter.cpp.

References CHECK_GE, and Parser::RegexpExpr::get().

317  {
318  const auto& operands = expr["operands"];
319  CHECK_GE(operands.Size(), unsigned(2));
320  auto lhs = getExprFromNode(operands[0], scan_targets);
321  auto rhs = getExprFromNode(operands[1], scan_targets);
322  auto esc = operands.Size() > 2 ? getExprFromNode(operands[2], scan_targets) : nullptr;
323  return Parser::RegexpExpr::get(lhs, rhs, esc, false);
324  }
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
#define CHECK_GE(x, y)
Definition: Logger.h:203
static std::shared_ptr< Analyzer::Expr > get(std::shared_ptr< Analyzer::Expr > arg_expr, std::shared_ptr< Analyzer::Expr > pattern_expr, std::shared_ptr< Analyzer::Expr > escape_expr, const bool is_not)
Definition: ParserNode.cpp:625
const int32_t groups_buffer_size return nullptr

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateTypedLiteral ( const rapidjson::Value &  expr)
inline

Definition at line 505 of file CalciteAdapter.cpp.

References Parser::StringLiteral::analyzeValue(), Parser::IntLiteral::analyzeValue(), Parser::FixedPtLiteral::analyzeValue(), Datum::bigintval, Datum::boolval, CHECK(), Datum::doubleval, logger::FATAL, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNULLT, kTEXT, kTIME, kTIMESTAMP, LOG, make_fp_constant(), and anonymous_namespace{CalciteAdapter.cpp}::parse_literal().

505  {
506  const auto parsed_lit = parse_literal(expr);
507  const auto& lit_ti = std::get<1>(parsed_lit);
508  const auto json_val = std::get<0>(parsed_lit);
509  switch (lit_ti.get_type()) {
510  case kDECIMAL: {
511  CHECK(json_val->IsInt64());
512  const auto val = json_val->GetInt64();
513  const int precision = lit_ti.get_precision();
514  const int scale = lit_ti.get_scale();
515  const auto& target_ti = std::get<2>(parsed_lit);
516  if (target_ti.is_fp() && !scale) {
517  return make_fp_constant(val, target_ti);
518  }
519  auto lit_expr = scale
520  ? Parser::FixedPtLiteral::analyzeValue(val, scale, precision)
521  : Parser::IntLiteral::analyzeValue(val);
522  return scale && lit_ti != target_ti ? lit_expr->add_cast(target_ti) : lit_expr;
523  }
524  case kINTERVAL_DAY_TIME:
525  case kINTERVAL_YEAR_MONTH: {
526  CHECK(json_val->IsInt64());
527  Datum d;
528  d.bigintval = json_val->GetInt64();
529  return makeExpr<Analyzer::Constant>(lit_ti.get_type(), false, d);
530  }
531  case kTIME:
532  case kTIMESTAMP: {
533  CHECK(json_val->IsInt64());
534  Datum d;
535  d.bigintval = json_val->GetInt64() / 1000;
536  return makeExpr<Analyzer::Constant>(lit_ti.get_type(), false, d);
537  }
538  case kDATE: {
539  CHECK(json_val->IsInt64());
540  Datum d;
541  d.bigintval = json_val->GetInt64() * 24 * 3600;
542  return makeExpr<Analyzer::Constant>(lit_ti.get_type(), false, d);
543  }
544  case kTEXT: {
545  CHECK(json_val->IsString());
546  const auto val = json_val->GetString();
548  }
549  case kBOOLEAN: {
550  CHECK(json_val->IsBool());
551  Datum d;
552  d.boolval = json_val->GetBool();
553  return makeExpr<Analyzer::Constant>(kBOOLEAN, false, d);
554  }
555  case kDOUBLE: {
556  CHECK(json_val->IsDouble());
557  Datum d;
558  d.doubleval = json_val->GetDouble();
559  const auto& target_ti = std::get<2>(parsed_lit);
560  auto lit_expr = makeExpr<Analyzer::Constant>(kDOUBLE, false, d);
561  return lit_ti != target_ti ? lit_expr->add_cast(target_ti) : lit_expr;
562  }
563  case kNULLT: {
564  const auto& target_ti = std::get<2>(parsed_lit);
565  return makeExpr<Analyzer::Constant>(target_ti.get_type(), true, Datum{0});
566  }
567  default: {
568  LOG(FATAL) << "Unexpected literal type " << lit_ti.get_type_name();
569  }
570  }
571  return nullptr;
572  }
Definition: sqltypes.h:52
#define LOG(tag)
Definition: Logger.h:185
bool boolval
Definition: sqltypes.h:125
CHECK(cgen_state)
int64_t bigintval
Definition: sqltypes.h:129
static std::shared_ptr< Analyzer::Expr > analyzeValue(const std::string &)
Definition: ParserNode.cpp:97
std::tuple< const rapidjson::Value *, SQLTypeInfo, SQLTypeInfo > parse_literal(const rapidjson::Value &expr)
Definition: sqltypes.h:55
Definition: sqltypes.h:56
static std::shared_ptr< Analyzer::Expr > analyzeValue(const int64_t numericval, const int scale, const int precision)
Definition: ParserNode.cpp:137
std::shared_ptr< Analyzer::Constant > make_fp_constant(const int64_t val, const SQLTypeInfo &ti)
double doubleval
Definition: sqltypes.h:131

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateUnaryOp ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 256 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, anonymous_namespace{TypedDataAccessors.h}::is_null(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_time(), kBOOLEAN, kCAST, kFUNCTION, kIN, kISNOTNULL, kISNULL, kMINUS, kNOT, kUMINUS, kUNNEST, to_sql_op(), and to_sql_type().

258  {
259  const auto& operands = expr["operands"];
260  CHECK_EQ(unsigned(1), operands.Size());
261  const auto operand_expr = getExprFromNode(operands[0], scan_targets);
262  const auto op_str = expr["op"].GetString();
263  const auto sql_op = to_sql_op(op_str);
264  switch (sql_op) {
265  case kCAST: {
266  const auto& expr_type = expr["type"];
267  SQLTypeInfo target_ti(to_sql_type(expr_type["type"].GetString()),
268  !expr_type["nullable"].GetBool());
269  const auto& operand_ti = operand_expr->get_type_info();
270  if (target_ti.is_time() ||
271  operand_ti
272  .is_string()) { // TODO(alex): check and unify with the rest of the cases
273  return operand_expr->add_cast(target_ti);
274  }
275  return makeExpr<Analyzer::UOper>(target_ti, false, sql_op, operand_expr);
276  }
277  case kNOT:
278  case kISNULL: {
279  return makeExpr<Analyzer::UOper>(kBOOLEAN, sql_op, operand_expr);
280  }
281  case kISNOTNULL: {
282  auto is_null = makeExpr<Analyzer::UOper>(kBOOLEAN, kISNULL, operand_expr);
283  return makeExpr<Analyzer::UOper>(kBOOLEAN, kNOT, is_null);
284  }
285  case kMINUS: {
286  const auto& ti = operand_expr->get_type_info();
287  return makeExpr<Analyzer::UOper>(ti, false, kUMINUS, operand_expr);
288  }
289  case kUNNEST: {
290  const auto& ti = operand_expr->get_type_info();
291  CHECK(ti.is_array());
292  return makeExpr<Analyzer::UOper>(
293  ti.get_elem_type(), false, kUNNEST, operand_expr);
294  }
295  default: {
296  CHECK(sql_op == kFUNCTION || sql_op == kIN);
297  throw std::runtime_error(std::string("Unsupported unary operator: ") + op_str);
298  }
299  }
300  return nullptr;
301  }
SQLTypes to_sql_type(const std::string &type_name)
#define CHECK_EQ(x, y)
Definition: Logger.h:198
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
Definition: sqldefs.h:49
CHECK(cgen_state)
SQLOps to_sql_op(const std::string &op_str)
Definition: sqldefs.h:40
bool is_null(const T &v, const SQLTypeInfo &t)
Definition: sqldefs.h:53
Definition: sqldefs.h:39

+ Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateUnlikely ( const rapidjson::Value &  expr,
const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &  scan_targets 
)
inline

Definition at line 335 of file CalciteAdapter.cpp.

References CHECK_GE, and Parser::LikelihoodExpr::get().

337  {
338  const auto& operands = expr["operands"];
339  CHECK_GE(operands.Size(), unsigned(1));
340  auto arg = getExprFromNode(operands[0], scan_targets);
341  return Parser::LikelihoodExpr::get(arg, 0.0625, false);
342  }
std::shared_ptr< Analyzer::Expr > getExprFromNode(const rapidjson::Value &expr, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets)
#define CHECK_GE(x, y)
Definition: Logger.h:203
static std::shared_ptr< Analyzer::Expr > get(std::shared_ptr< Analyzer::Expr > arg_expr, float likelihood, const bool is_not)
Definition: ParserNode.cpp:676

+ Here is the call graph for this function:

Member Data Documentation

const Catalog_Namespace::Catalog& anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::cat_
private

Definition at line 623 of file CalciteAdapter.cpp.

std::vector<ColNames> anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::col_names_
private

Definition at line 625 of file CalciteAdapter.cpp.

time_t anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::now_
private

Definition at line 624 of file CalciteAdapter.cpp.

std::unordered_map<int32_t, std::set<int> > anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::used_columns_
private

Definition at line 622 of file CalciteAdapter.cpp.


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