OmniSciDB  dfae7c3b14
Parser::InsertIntoTableAsSelectStmt Class Reference

#include <ParserNode.h>

+ Inheritance diagram for Parser::InsertIntoTableAsSelectStmt:
+ Collaboration diagram for Parser::InsertIntoTableAsSelectStmt:

Public Member Functions

 InsertIntoTableAsSelectStmt (const std::string *table_name, const std::string *select_query, std::list< std::string *> *c)
 
void populateData (QueryStateProxy, bool validate_table)
 
void execute (const Catalog_Namespace::SessionInfo &session) override
 
std::string & get_table ()
 
std::string & get_select_query ()
 
- Public Member Functions inherited from Parser::DDLStmt
void setColumnDescriptor (ColumnDescriptor &cd, const ColumnDef *coldef)
 
- Public Member Functions inherited from Parser::Node
virtual ~Node ()
 

Public Attributes

DistributedConnectorleafs_connector_ = nullptr
 

Protected Attributes

std::vector< std::unique_ptr< std::string > > column_list_
 
std::string table_name_
 
std::string select_query_
 

Detailed Description

Definition at line 1072 of file ParserNode.h.

Constructor & Destructor Documentation

◆ InsertIntoTableAsSelectStmt()

Parser::InsertIntoTableAsSelectStmt::InsertIntoTableAsSelectStmt ( const std::string *  table_name,
const std::string *  select_query,
std::list< std::string *> *  c 
)
inline

Definition at line 1075 of file ParserNode.h.

1078  : table_name_(*table_name), select_query_(*select_query) {
1079  if (c) {
1080  for (auto e : *c) {
1081  column_list_.emplace_back(e);
1082  }
1083  delete c;
1084  }
1085 
1086  delete table_name;
1087  delete select_query;
1088  }
std::vector< std::unique_ptr< std::string > > column_list_
Definition: ParserNode.h:1100

Member Function Documentation

◆ execute()

void Parser::InsertIntoTableAsSelectStmt::execute ( const Catalog_Namespace::SessionInfo session)
overridevirtual

Implements Parser::DDLStmt.

Reimplemented in Parser::CreateTableAsSelectStmt.

Definition at line 2957 of file ParserNode.cpp.

References query_state::QueryState::create(), and STDLOG.

Referenced by omnisci.cursor.Cursor::executemany().

2957  {
2958  auto session_copy = session;
2959  auto session_ptr = std::shared_ptr<Catalog_Namespace::SessionInfo>(
2960  &session_copy, boost::null_deleter());
2962  auto stdlog = STDLOG(query_state);
2963  populateData(query_state->createQueryStateProxy(), true);
2964 }
void populateData(QueryStateProxy, bool validate_table)
static std::shared_ptr< QueryState > create(ARGS &&... args)
Definition: QueryState.h:140
#define STDLOG(...)
Definition: QueryState.h:225
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_select_query()

std::string& Parser::InsertIntoTableAsSelectStmt::get_select_query ( )
inline

Definition at line 1095 of file ParserNode.h.

1095 { return select_query_; }

◆ get_table()

std::string& Parser::InsertIntoTableAsSelectStmt::get_table ( )
inline

Definition at line 1093 of file ParserNode.h.

1093 { return table_name_; }

◆ populateData()

void Parser::InsertIntoTableAsSelectStmt::populateData ( QueryStateProxy  query_state_proxy,
bool  validate_table 
)

Definition at line 2534 of file ParserNode.cpp.

References CHECK, ColumnDescriptor::columnName, ColumnDescriptor::columnType, TargetValueConverterFactory::create(), Fragmenter_Namespace::InsertData::databaseId, parse_ast::end, logger::ERROR, g_cluster, g_enable_experimental_string_functions, ResultSet::GeoTargetValue, SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_size(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), Parser::LocalConnector::getColumnDescriptors(), query_state::QueryState::getConstSessionInfo(), Executor::getExecutor(), query_state::QueryStateProxy::getQueryState(), lockmgr::TableLockMgrImpl< InsertDataLockMgr >::getWriteLockForTable(), AccessPrivileges::INSERT_INTO_TABLE, Fragmenter_Namespace::InsertDataLoader::insertData(), SQLTypeInfo::is_array(), SQLTypeInfo::is_date(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_geometry(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), SQLTypeInfo::is_timestamp(), LOG, num_rows, Fragmenter_Namespace::InsertData::numRows, Parser::LocalConnector::query(), run_benchmark_import::res, run_benchmark_import::result, table_is_temporary(), TableDBObjectType, Fragmenter_Namespace::InsertData::tableId, logger::thread_id(), timer_start(), timer_stop(), Executor::UNITARY_EXECUTOR_ID, foreign_storage::validate_non_foreign_table_write(), and VLOG.

2535  {
2536  auto const session = query_state_proxy.getQueryState().getConstSessionInfo();
2537  auto& catalog = session->getCatalog();
2538  const auto td_with_lock =
2540  catalog, table_name_);
2541  const auto td = td_with_lock();
2543 
2544  LocalConnector local_connector;
2545  bool populate_table = false;
2546 
2547  if (leafs_connector_) {
2548  populate_table = true;
2549  } else {
2550  leafs_connector_ = &local_connector;
2551  if (!g_cluster) {
2552  populate_table = true;
2553  }
2554  }
2555 
2556  auto get_target_column_descriptors = [this, &catalog](const TableDescriptor* td) {
2557  std::vector<const ColumnDescriptor*> target_column_descriptors;
2558  if (column_list_.empty()) {
2559  auto list = catalog.getAllColumnMetadataForTable(td->tableId, false, false, false);
2560  target_column_descriptors = {std::begin(list), std::end(list)};
2561 
2562  } else {
2563  for (auto& c : column_list_) {
2564  const ColumnDescriptor* cd = catalog.getMetadataForColumn(td->tableId, *c);
2565  if (cd == nullptr) {
2566  throw std::runtime_error("Column " + *c + " does not exist.");
2567  }
2568  target_column_descriptors.push_back(cd);
2569  }
2570  }
2571 
2572  return target_column_descriptors;
2573  };
2574 
2575  bool is_temporary = table_is_temporary(td);
2576 
2577  // Don't allow simultaneous inserts
2578  const auto insert_data_lock =
2580 
2581  if (validate_table) {
2582  // check access privileges
2583  if (!td) {
2584  throw std::runtime_error("Table " + table_name_ + " does not exist.");
2585  }
2586  if (td->isView) {
2587  throw std::runtime_error("Insert to views is not supported yet.");
2588  }
2589 
2590  if (!session->checkDBAccessPrivileges(DBObjectType::TableDBObjectType,
2592  table_name_)) {
2593  throw std::runtime_error("User has no insert privileges on " + table_name_ + ".");
2594  }
2595 
2596  // only validate the select query so we get the target types
2597  // correctly, but do not populate the result set
2598  auto result = local_connector.query(query_state_proxy, select_query_, {}, true);
2599  auto source_column_descriptors = local_connector.getColumnDescriptors(result, false);
2600 
2601  std::vector<const ColumnDescriptor*> target_column_descriptors =
2602  get_target_column_descriptors(td);
2603  if (catalog.getAllColumnMetadataForTable(td->tableId, false, false, false).size() !=
2604  target_column_descriptors.size()) {
2605  throw std::runtime_error("Insert into a subset of columns is not supported yet.");
2606  }
2607 
2608  if (source_column_descriptors.size() != target_column_descriptors.size()) {
2609  throw std::runtime_error("The number of source and target columns does not match.");
2610  }
2611 
2612  for (int i = 0; i < source_column_descriptors.size(); i++) {
2613  const ColumnDescriptor* source_cd =
2614  &(*std::next(source_column_descriptors.begin(), i));
2615  const ColumnDescriptor* target_cd = target_column_descriptors.at(i);
2616 
2617  if (source_cd->columnType.get_type() != target_cd->columnType.get_type()) {
2618  auto type_cannot_be_cast = [](const auto& col_type) {
2619  return (col_type.is_time() || col_type.is_geometry() || col_type.is_array() ||
2620  col_type.is_boolean());
2621  };
2622 
2623  if (type_cannot_be_cast(source_cd->columnType) ||
2624  type_cannot_be_cast(target_cd->columnType)) {
2625  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2626  source_cd->columnType.get_type_name() +
2627  "' and target '" + target_cd->columnName + " " +
2628  target_cd->columnType.get_type_name() +
2629  "' column types do not match.");
2630  }
2631  }
2632  if (source_cd->columnType.is_array()) {
2633  if (source_cd->columnType.get_subtype() != target_cd->columnType.get_subtype()) {
2634  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2635  source_cd->columnType.get_type_name() +
2636  "' and target '" + target_cd->columnName + " " +
2637  target_cd->columnType.get_type_name() +
2638  "' array column element types do not match.");
2639  }
2640  }
2641 
2642  if (source_cd->columnType.is_decimal() ||
2643  source_cd->columnType.get_elem_type().is_decimal()) {
2644  SQLTypeInfo sourceType = source_cd->columnType;
2645  SQLTypeInfo targetType = target_cd->columnType;
2646 
2647  if (source_cd->columnType.is_array()) {
2648  sourceType = source_cd->columnType.get_elem_type();
2649  targetType = target_cd->columnType.get_elem_type();
2650  }
2651 
2652  if (sourceType.get_scale() != targetType.get_scale()) {
2653  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2654  source_cd->columnType.get_type_name() +
2655  "' and target '" + target_cd->columnName + " " +
2656  target_cd->columnType.get_type_name() +
2657  "' decimal columns scales do not match.");
2658  }
2659  }
2660 
2661  if (source_cd->columnType.is_string()) {
2662  if (!target_cd->columnType.is_string()) {
2663  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2664  source_cd->columnType.get_type_name() +
2665  "' and target '" + target_cd->columnName + " " +
2666  target_cd->columnType.get_type_name() +
2667  "' column types do not match.");
2668  }
2669  if (source_cd->columnType.get_compression() !=
2670  target_cd->columnType.get_compression()) {
2671  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2672  source_cd->columnType.get_type_name() +
2673  "' and target '" + target_cd->columnName + " " +
2674  target_cd->columnType.get_type_name() +
2675  "' columns string encodings do not match.");
2676  }
2677  }
2678 
2679  if (source_cd->columnType.is_timestamp() && target_cd->columnType.is_timestamp()) {
2680  if (source_cd->columnType.get_dimension() !=
2681  target_cd->columnType.get_dimension()) {
2682  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2683  source_cd->columnType.get_type_name() +
2684  "' and target '" + target_cd->columnName + " " +
2685  target_cd->columnType.get_type_name() +
2686  "' timestamp column precisions do not match.");
2687  }
2688  }
2689 
2690  if (!source_cd->columnType.is_string() && !source_cd->columnType.is_geometry() &&
2691  !source_cd->columnType.is_integer() && !source_cd->columnType.is_decimal() &&
2692  !source_cd->columnType.is_date() && !source_cd->columnType.is_time() &&
2693  !source_cd->columnType.is_timestamp() &&
2694  source_cd->columnType.get_size() > target_cd->columnType.get_size()) {
2695  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2696  source_cd->columnType.get_type_name() +
2697  "' and target '" + target_cd->columnName + " " +
2698  target_cd->columnType.get_type_name() +
2699  "' column encoding sizes do not match.");
2700  }
2701  }
2702  }
2703 
2704  if (!populate_table) {
2705  return;
2706  }
2707 
2708  int64_t total_row_count = 0;
2709  int64_t total_source_query_time_ms = 0;
2710  int64_t total_target_value_translate_time_ms = 0;
2711  int64_t total_data_load_time_ms = 0;
2712 
2714  auto target_column_descriptors = get_target_column_descriptors(td);
2715 
2716  auto outer_frag_count =
2718 
2719  size_t outer_frag_end = outer_frag_count == 0 ? 1 : outer_frag_count;
2720 
2721  try {
2722  for (size_t outer_frag_idx = 0; outer_frag_idx < outer_frag_end; outer_frag_idx++) {
2723  std::vector<size_t> allowed_outer_fragment_indices;
2724 
2725  if (outer_frag_count) {
2726  allowed_outer_fragment_indices.push_back(outer_frag_idx);
2727  }
2728 
2729  const auto query_clock_begin = timer_start();
2730  std::vector<AggregatedResult> query_results = leafs_connector_->query(
2731  query_state_proxy, select_query_, allowed_outer_fragment_indices);
2732  total_source_query_time_ms += timer_stop(query_clock_begin);
2733 
2734  for (auto& res : query_results) {
2735  auto result_rows = res.rs;
2736  result_rows->setGeoReturnType(ResultSet::GeoReturnType::GeoTargetValue);
2737  const auto num_rows = result_rows->rowCount();
2738 
2739  if (0 == num_rows) {
2740  continue;
2741  }
2742 
2743  total_row_count += num_rows;
2744 
2745  size_t leaf_count = leafs_connector_->leafCount();
2746 
2747  size_t max_number_of_rows_per_package =
2748  std::min(num_rows / leaf_count, 64UL * 1024UL);
2749 
2750  size_t start_row = 0;
2751  size_t num_rows_to_process = std::min(num_rows, max_number_of_rows_per_package);
2752 
2753  // ensure that at least one row is being processed
2754  num_rows_to_process = std::max(num_rows_to_process, 1UL);
2755 
2756  std::vector<std::unique_ptr<TargetValueConverter>> value_converters;
2757 
2759 
2760  const int num_worker_threads = std::thread::hardware_concurrency();
2761 
2762  std::vector<size_t> thread_start_idx(num_worker_threads),
2763  thread_end_idx(num_worker_threads);
2764  bool can_go_parallel = !result_rows->isTruncated() && num_rows_to_process > 20000;
2765 
2766  std::atomic<size_t> row_idx{0};
2767 
2768  auto convert_function = [&result_rows,
2769  &value_converters,
2770  &row_idx,
2771  &num_rows_to_process,
2772  &thread_start_idx,
2773  &thread_end_idx](const int thread_id) {
2774  const int num_cols = value_converters.size();
2775  const size_t start = thread_start_idx[thread_id];
2776  const size_t end = thread_end_idx[thread_id];
2777  size_t idx = 0;
2778  for (idx = start; idx < end; ++idx) {
2779  const auto result_row = result_rows->getRowAtNoTranslations(idx);
2780  if (!result_row.empty()) {
2781  size_t target_row = row_idx.fetch_add(1);
2782 
2783  if (target_row >= num_rows_to_process) {
2784  break;
2785  }
2786 
2787  for (unsigned int col = 0; col < num_cols; col++) {
2788  const auto& mapd_variant = result_row[col];
2789  value_converters[col]->convertToColumnarFormat(target_row, &mapd_variant);
2790  }
2791  }
2792  }
2793 
2794  thread_start_idx[thread_id] = idx;
2795  };
2796 
2797  auto single_threaded_convert_function = [&result_rows,
2798  &value_converters,
2799  &row_idx,
2800  &num_rows_to_process,
2801  &thread_start_idx,
2802  &thread_end_idx](const int thread_id) {
2803  const int num_cols = value_converters.size();
2804  const size_t start = thread_start_idx[thread_id];
2805  const size_t end = thread_end_idx[thread_id];
2806  size_t idx = 0;
2807  for (idx = start; idx < end; ++idx) {
2808  size_t target_row = row_idx.fetch_add(1);
2809 
2810  if (target_row >= num_rows_to_process) {
2811  break;
2812  }
2813  const auto result_row = result_rows->getNextRow(false, false);
2814  CHECK(!result_row.empty());
2815  for (unsigned int col = 0; col < num_cols; col++) {
2816  const auto& mapd_variant = result_row[col];
2817  value_converters[col]->convertToColumnarFormat(target_row, &mapd_variant);
2818  }
2819  }
2820 
2821  thread_start_idx[thread_id] = idx;
2822  };
2823 
2824  if (can_go_parallel) {
2825  const size_t entryCount = result_rows->entryCount();
2826  for (size_t i = 0,
2827  start_entry = 0,
2828  stride = (entryCount + num_worker_threads - 1) / num_worker_threads;
2829  i < num_worker_threads && start_entry < entryCount;
2830  ++i, start_entry += stride) {
2831  const auto end_entry = std::min(start_entry + stride, entryCount);
2832  thread_start_idx[i] = start_entry;
2833  thread_end_idx[i] = end_entry;
2834  }
2835 
2836  } else {
2837  thread_start_idx[0] = 0;
2838  thread_end_idx[0] = result_rows->entryCount();
2839  }
2840 
2841  std::shared_ptr<Executor> executor;
2842 
2845  }
2846 
2847  while (start_row < num_rows) {
2848  value_converters.clear();
2849  row_idx = 0;
2850  int colNum = 0;
2851  for (const auto targetDescriptor : target_column_descriptors) {
2852  auto sourceDataMetaInfo = res.targets_meta[colNum++];
2853 
2855  num_rows_to_process,
2856  catalog,
2857  sourceDataMetaInfo,
2858  targetDescriptor,
2859  targetDescriptor->columnType,
2860  !targetDescriptor->columnType.get_notnull(),
2861  result_rows->getRowSetMemOwner()->getLiteralStringDictProxy(),
2863  ? executor->getStringDictionaryProxy(
2864  sourceDataMetaInfo.get_type_info().get_comp_param(),
2865  result_rows->getRowSetMemOwner(),
2866  true)
2867  : nullptr};
2868  auto converter = factory.create(param);
2869  value_converters.push_back(std::move(converter));
2870  }
2871 
2872  const auto translate_clock_begin = timer_start();
2873  if (can_go_parallel) {
2874  std::vector<std::future<void>> worker_threads;
2875  for (int i = 0; i < num_worker_threads; ++i) {
2876  worker_threads.push_back(
2877  std::async(std::launch::async, convert_function, i));
2878  }
2879 
2880  for (auto& child : worker_threads) {
2881  child.wait();
2882  }
2883  for (auto& child : worker_threads) {
2884  child.get();
2885  }
2886 
2887  } else {
2888  single_threaded_convert_function(0);
2889  }
2890 
2891  // finalize the insert data
2892  {
2893  auto finalizer_func =
2894  [](std::unique_ptr<TargetValueConverter>::pointer targetValueConverter) {
2895  targetValueConverter->finalizeDataBlocksForInsertData();
2896  };
2897  std::vector<std::future<void>> worker_threads;
2898  for (auto& converterPtr : value_converters) {
2899  worker_threads.push_back(
2900  std::async(std::launch::async, finalizer_func, converterPtr.get()));
2901  }
2902 
2903  for (auto& child : worker_threads) {
2904  child.wait();
2905  }
2906  for (auto& child : worker_threads) {
2907  child.get();
2908  }
2909  }
2910 
2912  insert_data.databaseId = catalog.getCurrentDB().dbId;
2913  CHECK(td);
2914  insert_data.tableId = td->tableId;
2915  insert_data.numRows = num_rows_to_process;
2916 
2917  for (int col_idx = 0; col_idx < target_column_descriptors.size(); col_idx++) {
2918  value_converters[col_idx]->addDataBlocksToInsertData(insert_data);
2919  }
2920  total_target_value_translate_time_ms += timer_stop(translate_clock_begin);
2921 
2922  const auto data_load_clock_begin = timer_start();
2923  insertDataLoader.insertData(*session, insert_data);
2924  total_data_load_time_ms += timer_stop(data_load_clock_begin);
2925 
2926  start_row += num_rows_to_process;
2927  num_rows_to_process =
2928  std::min(num_rows - start_row, max_number_of_rows_per_package);
2929  }
2930  }
2931  }
2932  } catch (...) {
2933  try {
2934  leafs_connector_->rollback(*session, td->tableId);
2935  } catch (std::exception& e) {
2936  LOG(ERROR) << "An error occurred during ITAS rollback attempt. Table id: "
2937  << td->tableId << ", Error: " << e.what();
2938  }
2939  throw;
2940  }
2941 
2942  int64_t total_time_ms = total_source_query_time_ms +
2943  total_target_value_translate_time_ms + total_data_load_time_ms;
2944 
2945  VLOG(1) << "CTAS/ITAS " << total_row_count << " rows loaded in " << total_time_ms
2946  << "ms (outer_frag_count=" << outer_frag_count
2947  << ", query_time=" << total_source_query_time_ms
2948  << "ms, translation_time=" << total_target_value_translate_time_ms
2949  << "ms, data_load_time=" << total_data_load_time_ms
2950  << "ms)\nquery: " << select_query_;
2951 
2952  if (!is_temporary) {
2953  leafs_connector_->checkpoint(*session, td->tableId);
2954  }
2955 }
void validate_non_foreign_table_write(const TableDescriptor *table_descriptor)
Definition: FsiUtils.h:22
virtual std::vector< AggregatedResult > query(QueryStateProxy, std::string &sql_query_string, std::vector< size_t > outer_frag_indices)=0
bool is_time() const
Definition: sqltypes.h:423
bool is_array() const
Definition: sqltypes.h:425
bool is_string() const
Definition: sqltypes.h:417
const int8_t const int64_t * num_rows
bool is_integer() const
Definition: sqltypes.h:419
#define LOG(tag)
Definition: Logger.h:188
static WriteLock getWriteLockForTable(const Catalog_Namespace::Catalog &cat, const std::string &table_name)
Definition: LockMgrImpl.h:155
static const AccessPrivileges INSERT_INTO_TABLE
Definition: DBObject.h:162
TypeR::rep timer_stop(Type clock_begin)
Definition: measure.h:48
bool is_date() const
Definition: sqltypes.h:642
HOST DEVICE int get_size() const
Definition: sqltypes.h:269
static std::shared_ptr< Executor > getExecutor(const ExecutorId id, const std::string &debug_dir="", const std::string &debug_file="", const SystemParameters system_parameters=SystemParameters())
Definition: Execute.cpp:150
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:267
bool is_decimal() const
Definition: sqltypes.h:420
HOST DEVICE int get_scale() const
Definition: sqltypes.h:264
int tableId
identifies the database into which the data is being inserted
Definition: Fragmenter.h:61
size_t numRows
a vector of column ids for the row(s) being inserted
Definition: Fragmenter.h:63
QueryState & getQueryState()
Definition: QueryState.h:172
HOST DEVICE SQLTypes get_subtype() const
Definition: sqltypes.h:260
virtual size_t getOuterFragmentCount(QueryStateProxy, std::string &sql_query_string)=0
specifies the content in-memory of a row in the column metadata table
bool g_enable_experimental_string_functions
bool is_geometry() const
Definition: sqltypes.h:429
std::shared_ptr< Catalog_Namespace::SessionInfo const > getConstSessionInfo() const
Definition: QueryState.cpp:77
std::string get_type_name() const
Definition: sqltypes.h:362
bool table_is_temporary(const TableDescriptor *const td)
virtual void rollback(const Catalog_Namespace::SessionInfo &parent_session_info, int tableId)=0
HOST DEVICE int get_dimension() const
Definition: sqltypes.h:261
virtual void checkpoint(const Catalog_Namespace::SessionInfo &parent_session_info, int tableId)=0
std::vector< std::unique_ptr< std::string > > column_list_
Definition: ParserNode.h:1100
ThreadId thread_id()
Definition: Logger.cpp:731
DistributedConnector * leafs_connector_
Definition: ParserNode.h:1097
SQLTypeInfo get_elem_type() const
Definition: sqltypes.h:624
#define CHECK(condition)
Definition: Logger.h:197
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:259
bool g_cluster
The data to be inserted using the fragment manager.
Definition: Fragmenter.h:59
SQLTypeInfo columnType
specifies the content in-memory of a row in the table metadata table
bool is_timestamp() const
Definition: sqltypes.h:654
std::string columnName
#define VLOG(n)
Definition: Logger.h:291
Type timer_start()
Definition: measure.h:42
std::unique_ptr< TargetValueConverter > create(ConverterCreateParameter param)
static const ExecutorId UNITARY_EXECUTOR_ID
Definition: Execute.h:337
+ Here is the call graph for this function:

Member Data Documentation

◆ column_list_

std::vector<std::unique_ptr<std::string> > Parser::InsertIntoTableAsSelectStmt::column_list_
protected

Definition at line 1100 of file ParserNode.h.

◆ leafs_connector_

DistributedConnector* Parser::InsertIntoTableAsSelectStmt::leafs_connector_ = nullptr

Definition at line 1097 of file ParserNode.h.

◆ select_query_

std::string Parser::InsertIntoTableAsSelectStmt::select_query_
protected

Definition at line 1102 of file ParserNode.h.

◆ table_name_

std::string Parser::InsertIntoTableAsSelectStmt::table_name_
protected

Definition at line 1101 of file ParserNode.h.


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