OmniSciDB  06b3bd477c
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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

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.

References column_list_.

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

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

Implements Parser::DDLStmt.

Reimplemented in Parser::CreateTableAsSelectStmt.

Definition at line 2969 of file ParserNode.cpp.

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

2969  {
2970  auto session_copy = session;
2971  auto session_ptr = std::shared_ptr<Catalog_Namespace::SessionInfo>(
2972  &session_copy, boost::null_deleter());
2973  auto query_state = query_state::QueryState::create(session_ptr, select_query_);
2974  auto stdlog = STDLOG(query_state);
2975  populateData(query_state->createQueryStateProxy(), true);
2976 }
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:

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

Definition at line 1095 of file ParserNode.h.

References select_query_.

1095 { return select_query_; }
std::string& Parser::InsertIntoTableAsSelectStmt::get_table ( )
inline

Definition at line 1093 of file ParserNode.h.

References table_name_.

1093 { return table_name_; }
void Parser::InsertIntoTableAsSelectStmt::populateData ( QueryStateProxy  query_state_proxy,
bool  validate_table 
)

Definition at line 2535 of file ParserNode.cpp.

References CHECK(), ColumnDescriptor::columnName, ColumnDescriptor::columnType, TargetValueConverterFactory::create(), Fragmenter_Namespace::InsertData::databaseId, 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(), 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.

2536  {
2537  auto const session = query_state_proxy.getQueryState().getConstSessionInfo();
2538  auto& catalog = session->getCatalog();
2539  const auto td_with_lock =
2541  catalog, table_name_);
2542  const auto td = td_with_lock();
2544 
2545  LocalConnector local_connector;
2546  bool populate_table = false;
2547 
2548  if (leafs_connector_) {
2549  populate_table = true;
2550  } else {
2551  leafs_connector_ = &local_connector;
2552  if (!g_cluster) {
2553  populate_table = true;
2554  }
2555  }
2556 
2557  auto get_target_column_descriptors = [this, &catalog](const TableDescriptor* td) {
2558  std::vector<const ColumnDescriptor*> target_column_descriptors;
2559  if (column_list_.empty()) {
2560  auto list = catalog.getAllColumnMetadataForTable(td->tableId, false, false, false);
2561  target_column_descriptors = {std::begin(list), std::end(list)};
2562 
2563  } else {
2564  for (auto& c : column_list_) {
2565  const ColumnDescriptor* cd = catalog.getMetadataForColumn(td->tableId, *c);
2566  if (cd == nullptr) {
2567  throw std::runtime_error("Column " + *c + " does not exist.");
2568  }
2569  target_column_descriptors.push_back(cd);
2570  }
2571  }
2572 
2573  return target_column_descriptors;
2574  };
2575 
2576  bool is_temporary = table_is_temporary(td);
2577 
2578  // Don't allow simultaneous inserts
2579  const auto insert_data_lock =
2581 
2582  if (validate_table) {
2583  // check access privileges
2584  if (!td) {
2585  throw std::runtime_error("Table " + table_name_ + " does not exist.");
2586  }
2587  if (td->isView) {
2588  throw std::runtime_error("Insert to views is not supported yet.");
2589  }
2590 
2591  if (!session->checkDBAccessPrivileges(DBObjectType::TableDBObjectType,
2593  table_name_)) {
2594  throw std::runtime_error("User has no insert privileges on " + table_name_ + ".");
2595  }
2596 
2597  // only validate the select query so we get the target types
2598  // correctly, but do not populate the result set
2599  auto result = local_connector.query(query_state_proxy, select_query_, {}, true);
2600  auto source_column_descriptors = local_connector.getColumnDescriptors(result, false);
2601 
2602  std::vector<const ColumnDescriptor*> target_column_descriptors =
2603  get_target_column_descriptors(td);
2604  if (catalog.getAllColumnMetadataForTable(td->tableId, false, false, false).size() !=
2605  target_column_descriptors.size()) {
2606  throw std::runtime_error("Insert into a subset of columns is not supported yet.");
2607  }
2608 
2609  if (source_column_descriptors.size() != target_column_descriptors.size()) {
2610  throw std::runtime_error("The number of source and target columns does not match.");
2611  }
2612 
2613  for (int i = 0; i < source_column_descriptors.size(); i++) {
2614  const ColumnDescriptor* source_cd =
2615  &(*std::next(source_column_descriptors.begin(), i));
2616  const ColumnDescriptor* target_cd = target_column_descriptors.at(i);
2617 
2618  if (source_cd->columnType.get_type() != target_cd->columnType.get_type()) {
2619  auto type_cannot_be_cast = [](const auto& col_type) {
2620  return (col_type.is_time() || col_type.is_geometry() || col_type.is_array() ||
2621  col_type.is_boolean());
2622  };
2623 
2624  if (type_cannot_be_cast(source_cd->columnType) ||
2625  type_cannot_be_cast(target_cd->columnType)) {
2626  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2627  source_cd->columnType.get_type_name() +
2628  "' and target '" + target_cd->columnName + " " +
2629  target_cd->columnType.get_type_name() +
2630  "' column types do not match.");
2631  }
2632  }
2633  if (source_cd->columnType.is_array()) {
2634  if (source_cd->columnType.get_subtype() != target_cd->columnType.get_subtype()) {
2635  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2636  source_cd->columnType.get_type_name() +
2637  "' and target '" + target_cd->columnName + " " +
2638  target_cd->columnType.get_type_name() +
2639  "' array column element types do not match.");
2640  }
2641  }
2642 
2643  if (source_cd->columnType.is_decimal() ||
2644  source_cd->columnType.get_elem_type().is_decimal()) {
2645  SQLTypeInfo sourceType = source_cd->columnType;
2646  SQLTypeInfo targetType = target_cd->columnType;
2647 
2648  if (source_cd->columnType.is_array()) {
2649  sourceType = source_cd->columnType.get_elem_type();
2650  targetType = target_cd->columnType.get_elem_type();
2651  }
2652 
2653  if (sourceType.get_scale() != targetType.get_scale()) {
2654  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2655  source_cd->columnType.get_type_name() +
2656  "' and target '" + target_cd->columnName + " " +
2657  target_cd->columnType.get_type_name() +
2658  "' decimal columns scales do not match.");
2659  }
2660  }
2661 
2662  if (source_cd->columnType.is_string()) {
2663  if (!target_cd->columnType.is_string()) {
2664  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2665  source_cd->columnType.get_type_name() +
2666  "' and target '" + target_cd->columnName + " " +
2667  target_cd->columnType.get_type_name() +
2668  "' column types do not match.");
2669  }
2670  if (source_cd->columnType.get_compression() !=
2671  target_cd->columnType.get_compression()) {
2672  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2673  source_cd->columnType.get_type_name() +
2674  "' and target '" + target_cd->columnName + " " +
2675  target_cd->columnType.get_type_name() +
2676  "' columns string encodings do not match.");
2677  }
2678  }
2679 
2680  if (source_cd->columnType.is_timestamp() && target_cd->columnType.is_timestamp()) {
2681  if (source_cd->columnType.get_dimension() !=
2682  target_cd->columnType.get_dimension()) {
2683  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2684  source_cd->columnType.get_type_name() +
2685  "' and target '" + target_cd->columnName + " " +
2686  target_cd->columnType.get_type_name() +
2687  "' timestamp column precisions do not match.");
2688  }
2689  }
2690 
2691  if (!source_cd->columnType.is_string() && !source_cd->columnType.is_geometry() &&
2692  !source_cd->columnType.is_integer() && !source_cd->columnType.is_decimal() &&
2693  !source_cd->columnType.is_date() && !source_cd->columnType.is_time() &&
2694  !source_cd->columnType.is_timestamp() &&
2695  source_cd->columnType.get_size() > target_cd->columnType.get_size()) {
2696  throw std::runtime_error("Source '" + source_cd->columnName + " " +
2697  source_cd->columnType.get_type_name() +
2698  "' and target '" + target_cd->columnName + " " +
2699  target_cd->columnType.get_type_name() +
2700  "' column encoding sizes do not match.");
2701  }
2702  }
2703  }
2704 
2705  if (!populate_table) {
2706  return;
2707  }
2708 
2709  int64_t total_row_count = 0;
2710  int64_t total_source_query_time_ms = 0;
2711  int64_t total_target_value_translate_time_ms = 0;
2712  int64_t total_data_load_time_ms = 0;
2713 
2715  auto target_column_descriptors = get_target_column_descriptors(td);
2716 
2717  auto outer_frag_count =
2719 
2720  size_t outer_frag_end = outer_frag_count == 0 ? 1 : outer_frag_count;
2721 
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  try {
2849  value_converters.clear();
2850  row_idx = 0;
2851  int colNum = 0;
2852  for (const auto targetDescriptor : target_column_descriptors) {
2853  auto sourceDataMetaInfo = res.targets_meta[colNum++];
2854 
2856  num_rows_to_process,
2857  catalog,
2858  sourceDataMetaInfo,
2859  targetDescriptor,
2860  targetDescriptor->columnType,
2861  !targetDescriptor->columnType.get_notnull(),
2862  result_rows->getRowSetMemOwner()->getLiteralStringDictProxy(),
2864  ? executor->getStringDictionaryProxy(
2865  sourceDataMetaInfo.get_type_info().get_comp_param(),
2866  result_rows->getRowSetMemOwner(),
2867  true)
2868  : nullptr};
2869  auto converter = factory.create(param);
2870  value_converters.push_back(std::move(converter));
2871  }
2872 
2873  const auto translate_clock_begin = timer_start();
2874  if (can_go_parallel) {
2875  std::vector<std::future<void>> worker_threads;
2876  for (int i = 0; i < num_worker_threads; ++i) {
2877  worker_threads.push_back(
2878  std::async(std::launch::async, convert_function, i));
2879  }
2880 
2881  for (auto& child : worker_threads) {
2882  child.wait();
2883  }
2884  for (auto& child : worker_threads) {
2885  child.get();
2886  }
2887 
2888  } else {
2889  single_threaded_convert_function(0);
2890  }
2891 
2892  // finalize the insert data
2893  {
2894  auto finalizer_func =
2895  [](std::unique_ptr<TargetValueConverter>::pointer targetValueConverter) {
2896  targetValueConverter->finalizeDataBlocksForInsertData();
2897  };
2898  std::vector<std::future<void>> worker_threads;
2899  for (auto& converterPtr : value_converters) {
2900  worker_threads.push_back(
2901  std::async(std::launch::async, finalizer_func, converterPtr.get()));
2902  }
2903 
2904  for (auto& child : worker_threads) {
2905  child.wait();
2906  }
2907  for (auto& child : worker_threads) {
2908  child.get();
2909  }
2910  }
2911 
2913  insert_data.databaseId = catalog.getCurrentDB().dbId;
2914  CHECK(td);
2915  insert_data.tableId = td->tableId;
2916  insert_data.numRows = num_rows_to_process;
2917 
2918  for (int col_idx = 0; col_idx < target_column_descriptors.size(); col_idx++) {
2919  value_converters[col_idx]->addDataBlocksToInsertData(insert_data);
2920  }
2921  total_target_value_translate_time_ms += timer_stop(translate_clock_begin);
2922 
2923  const auto data_load_clock_begin = timer_start();
2924  insertDataLoader.insertData(*session, insert_data);
2925  total_data_load_time_ms += timer_stop(data_load_clock_begin);
2926 
2927  } catch (...) {
2928  try {
2929  if (td->nShards) {
2930  const auto shard_tables = catalog.getPhysicalTablesDescriptors(td);
2931  for (const auto ptd : shard_tables) {
2932  leafs_connector_->rollback(*session, ptd->tableId);
2933  }
2934  }
2935  leafs_connector_->rollback(*session, td->tableId);
2936  } catch (...) {
2937  // eat it
2938  }
2939  throw;
2940  }
2941  start_row += num_rows_to_process;
2942  num_rows_to_process =
2943  std::min(num_rows - start_row, max_number_of_rows_per_package);
2944  }
2945  }
2946  }
2947 
2948  int64_t total_time_ms = total_source_query_time_ms +
2949  total_target_value_translate_time_ms + total_data_load_time_ms;
2950 
2951  VLOG(1) << "CTAS/ITAS " << total_row_count << " rows loaded in " << total_time_ms
2952  << "ms (outer_frag_count=" << outer_frag_count
2953  << ", query_time=" << total_source_query_time_ms
2954  << "ms, translation_time=" << total_target_value_translate_time_ms
2955  << "ms, data_load_time=" << total_data_load_time_ms
2956  << "ms)\nquery: " << select_query_;
2957 
2958  if (!is_temporary) {
2959  if (td->nShards) {
2960  const auto shard_tables = catalog.getPhysicalTablesDescriptors(td);
2961  for (const auto ptd : shard_tables) {
2962  leafs_connector_->checkpoint(*session, ptd->tableId);
2963  }
2964  }
2965  leafs_connector_->checkpoint(*session, td->tableId);
2966  }
2967 }
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
HOST DEVICE SQLTypes get_subtype() const
Definition: sqltypes.h:259
HOST DEVICE int get_size() const
Definition: sqltypes.h:268
const int8_t const int64_t * num_rows
bool is_timestamp() const
Definition: sqltypes.h:652
static WriteLock getWriteLockForTable(const Catalog_Namespace::Catalog &cat, const std::string &table_name)
Definition: LockMgrImpl.h:155
HOST DEVICE int get_scale() const
Definition: sqltypes.h:263
static const AccessPrivileges INSERT_INTO_TABLE
Definition: DBObject.h:162
TypeR::rep timer_stop(Type clock_begin)
Definition: measure.h:46
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:148
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:258
bool is_time() const
Definition: sqltypes.h:421
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
CHECK(cgen_state)
QueryState & getQueryState()
Definition: QueryState.h:172
bool is_integer() const
Definition: sqltypes.h:417
virtual size_t getOuterFragmentCount(QueryStateProxy, std::string &sql_query_string)=0
specifies the content in-memory of a row in the column metadata table
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:266
bool table_is_temporary(const TableDescriptor *const td)
virtual void rollback(const Catalog_Namespace::SessionInfo &parent_session_info, int tableId)=0
bool g_enable_experimental_string_functions
HOST DEVICE int get_dimension() const
Definition: sqltypes.h:260
std::string get_type_name() const
Definition: sqltypes.h:361
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:715
DistributedConnector * leafs_connector_
Definition: ParserNode.h:1097
bool is_geometry() const
Definition: sqltypes.h:427
bool g_cluster
The data to be inserted using the fragment manager.
Definition: Fragmenter.h:59
SQLTypeInfo columnType
bool is_string() const
Definition: sqltypes.h:415
specifies the content in-memory of a row in the table metadata table
SQLTypeInfo get_elem_type() const
Definition: sqltypes.h:622
bool is_decimal() const
Definition: sqltypes.h:418
std::string columnName
std::shared_ptr< Catalog_Namespace::SessionInfo const > getConstSessionInfo() const
Definition: QueryState.cpp:77
bool is_date() const
Definition: sqltypes.h:640
bool is_array() const
Definition: sqltypes.h:423
#define VLOG(n)
Definition: Logger.h:291
Type timer_start()
Definition: measure.h:40
std::unique_ptr< TargetValueConverter > create(ConverterCreateParameter param)
static const ExecutorId UNITARY_EXECUTOR_ID
Definition: Execute.h:303

+ Here is the call graph for this function:

Member Data Documentation

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

Definition at line 1100 of file ParserNode.h.

Referenced by InsertIntoTableAsSelectStmt().

DistributedConnector* Parser::InsertIntoTableAsSelectStmt::leafs_connector_ = nullptr

Definition at line 1097 of file ParserNode.h.

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

Definition at line 1102 of file ParserNode.h.

Referenced by get_select_query().

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

Definition at line 1101 of file ParserNode.h.

Referenced by get_table().


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