anonymous_namespace{ExternalExecutor.cpp} Namespace Reference

Classes
struct	OmniSciVtab
struct	OmniSciCursor
struct	DecodedString

Functions
int	vt_destructor (sqlite3_vtab *pVtab)
int	vt_create (sqlite3 *db, void *p_aux, int argc, const char *const *argv, sqlite3_vtab **pp_vt, char **pzErr)
int	vt_connect (sqlite3 *db, void *p_aux, int argc, const char *const *argv, sqlite3_vtab **pp_vt, char **pzErr)
int	vt_disconnect (sqlite3_vtab *pVtab)
int	vt_destroy (sqlite3_vtab *pVtab)
int	vt_open (sqlite3_vtab *pVTab, sqlite3_vtab_cursor **pp_cursor)
int	vt_close (sqlite3_vtab_cursor *cur)
int	vt_eof (sqlite3_vtab_cursor *cur)
int64_t	get_num_rows (OmniSciCursor *p_cur)
int	vt_next (sqlite3_vtab_cursor *cur)
template<class T >
DecodedString	decode_string (const int8_t *column, const size_t cursor, StringDictionaryProxy *sdp)
int	vt_column (sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int col_idx)
int	vt_rowid (sqlite3_vtab_cursor *cur, sqlite_int64 *p_rowid)
int	vt_filter (sqlite3_vtab_cursor *p_vtc, int idxNum, const char *idxStr, int argc, sqlite3_value **argv)
int	vt_best_index (sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo)
std::vector< TargetMetaInfo >	create_table_schema (const PlanState *plan_state)
int64_t *	get_scan_output_slot (int64_t *output_buffer, const size_t output_buffer_entry_count, const size_t pos, const size_t row_size_quad)

Variables
sqlite3_module	omnisci_module

Function Documentation

std::vector<TargetMetaInfo> anonymous_namespace{ExternalExecutor.cpp}::create_table_schema

(

const PlanState *

plan_state

)

Definition at line 348 of file ExternalExecutor.cpp.

References CHECK, PlanState::executor_, get_temporary_table(), SQLTypeInfo::get_type_name(), Catalog_Namespace::SysCatalog::getCatalog(), PlanState::global_to_local_col_ids_, Catalog_Namespace::SysCatalog::instance(), is_supported_type_for_extern_execution(), and serialize_column_ref().

Referenced by run_query_external().

                                                                           {
  std::map<size_t, TargetMetaInfo> schema_map;
  for (const auto& kv : plan_state->global_to_local_col_ids_) {
    const auto& table_key = kv.first.getScanDesc().getTableKey();
    const auto catalog =
        Catalog_Namespace::SysCatalog::instance().getCatalog(table_key.db_id);
    const int column_id = kv.first.getColId();
    SQLTypeInfo column_type;
    if (table_key.table_id < 0) {
      const auto result_set = get_temporary_table(
          plan_state->executor_->getTemporaryTables(), table_key.table_id);
      column_type = result_set->getColType(column_id);
    } else {
      CHECK(catalog);
      const auto cd = catalog->getMetadataForColumn(table_key.table_id, column_id);
      column_type = cd->columnType;
    }
    if (!is_supported_type_for_extern_execution(column_type)) {
      throw std::runtime_error("Type not supported yet for extern execution: " +
                               column_type.get_type_name());
    }
    const auto column_ref =
        serialize_column_ref(table_key.table_id, column_id, catalog.get());
    const auto it_ok =
        schema_map.emplace(kv.second, TargetMetaInfo(column_ref, column_type));
    CHECK(it_ok.second);
  }
  std::vector<TargetMetaInfo> schema;
  for (const auto& kv : schema_map) {
    schema.push_back(kv.second);
  }
  return schema;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

DecodedString anonymous_namespace{ExternalExecutor.cpp}::decode_string	(	const int8_t *	column,
		const size_t	cursor,
		StringDictionaryProxy *	sdp
	)

Definition at line 154 of file ExternalExecutor.cpp.

References StringDictionaryProxy::getStringBytes(), run_benchmark_import::result, and heavydb.dtypes::T.

                                                        {
  const auto ids_column = reinterpret_cast<const T*>(column);
  const auto val = ids_column[cursor];
  DecodedString result{};
  if (val == inline_int_null_value<T>()) {
    result.is_null = true;
  } else {
    result.payload = sdp->getStringBytes(val);
  }
  return result;
}

Here is the call graph for this function:

int64_t anonymous_namespace{ExternalExecutor.cpp}::get_num_rows

(

OmniSciCursor *

p_cur

)

Definition at line 127 of file ExternalExecutor.cpp.

References anonymous_namespace{ExternalExecutor.cpp}::OmniSciCursor::base, and CHECK_EQ.

Referenced by vt_column(), and vt_next().

                                           {
  auto p = reinterpret_cast<OmniSciVtab*>(p_cur->base.pVtab);
  CHECK_EQ(p->external_query_table->fetch_result.num_rows.size(), size_t(1));
  CHECK_EQ(p->external_query_table->fetch_result.num_rows.front().size(), size_t(1));
  return p->external_query_table->fetch_result.num_rows.front().front();
}

Here is the caller graph for this function:

int64_t* anonymous_namespace{ExternalExecutor.cpp}::get_scan_output_slot	(	int64_t *	output_buffer,
		const size_t	output_buffer_entry_count,
		const size_t	pos,
		const size_t	row_size_quad
	)

Definition at line 407 of file ExternalExecutor.cpp.

References CHECK_LT.

                                                          {
  const auto off = pos * row_size_quad;
  CHECK_LT(pos, output_buffer_entry_count);
  output_buffer[off] = off;
  return output_buffer + off + 1;
}

int anonymous_namespace{ExternalExecutor.cpp}::vt_best_index	(	sqlite3_vtab *	tab,
		sqlite3_index_info *	pIdxInfo
	)

Definition at line 318 of file ExternalExecutor.cpp.

                                                                   {
  return SQLITE_OK;
}

int anonymous_namespace{ExternalExecutor.cpp}::vt_close

(

sqlite3_vtab_cursor *

cur

)

Definition at line 116 of file ExternalExecutor.cpp.

References report::cur.

                                       {
  auto p_cur = reinterpret_cast<OmniSciCursor*>(cur);
  sqlite3_free(p_cur);

  return SQLITE_OK;
}

int anonymous_namespace{ExternalExecutor.cpp}::vt_column	(	sqlite3_vtab_cursor *	cur,
		sqlite3_context *	ctx,
		int	col_idx
	)

Definition at line 168 of file ExternalExecutor.cpp.

References CHECK, CHECK_LE, CHECK_LT, ChunkIter_get_nth(), report::cur, logger::FATAL, get_num_rows(), inline_fp_null_value< double >(), inline_fp_null_value< float >(), VarlenDatum::is_null, anonymous_namespace{ExternalExecutor.cpp}::DecodedString::is_null, kBIGINT, kDOUBLE, kENCODING_DICT, kENCODING_NONE, kFLOAT, kINT, kSMALLINT, kTEXT, kTINYINT, VarlenDatum::length, LOG, anonymous_namespace{ExternalExecutor.cpp}::DecodedString::payload, and VarlenDatum::pointer.

                                                                           {
  auto p_cur = reinterpret_cast<OmniSciCursor*>(cur);
  const auto num_rows = get_num_rows(p_cur);

  auto p = reinterpret_cast<OmniSciVtab*>(p_cur->base.pVtab);
  const auto& external_query_table = *(p->external_query_table);
  CHECK_LT(static_cast<size_t>(col_idx),
           external_query_table.fetch_result.col_buffers[0].size());
  const auto column = external_query_table.fetch_result.col_buffers[0][col_idx];
  const auto& col_ti = external_query_table.schema[col_idx].get_type_info();
  switch (col_ti.get_type()) {
    case kTINYINT: {
      const auto val = column[p_cur->count - 1];
      if (val == inline_int_null_value<int8_t>()) {
        sqlite3_result_null(ctx);
      } else {
        sqlite3_result_int(ctx, val);
      }
      break;
    }
    case kSMALLINT: {
      const auto int_column = reinterpret_cast<const int16_t*>(column);
      const auto val = int_column[p_cur->count - 1];
      if (val == inline_int_null_value<int16_t>()) {
        sqlite3_result_null(ctx);
      } else {
        sqlite3_result_int(ctx, val);
      }
      break;
    }
    case kINT: {
      const auto int_column = reinterpret_cast<const int32_t*>(column);
      const auto val = int_column[p_cur->count - 1];
      if (val == inline_int_null_value<int32_t>()) {
        sqlite3_result_null(ctx);
      } else {
        sqlite3_result_int(ctx, val);
      }
      break;
    }
    case kBIGINT: {
      const auto int_column = reinterpret_cast<const int64_t*>(column);
      const auto val = int_column[p_cur->count - 1];
      if (val == inline_int_null_value<int64_t>()) {
        sqlite3_result_null(ctx);
      } else {
        sqlite3_result_int(ctx, val);
      }
      break;
    }
    case kFLOAT: {
      const auto float_column = reinterpret_cast<const float*>(column);
      const auto val = float_column[p_cur->count - 1];
      if (val == inline_fp_null_value<float>()) {
        sqlite3_result_null(ctx);
      } else {
        sqlite3_result_double(ctx, val);
      }
      break;
    }
    case kDOUBLE: {
      const auto double_column = reinterpret_cast<const double*>(column);
      const auto val = double_column[p_cur->count - 1];
      if (val == inline_fp_null_value<double>()) {
        sqlite3_result_null(ctx);
      } else {
        sqlite3_result_double(ctx, val);
      }
      break;
    }
    case kTEXT: {
      if (col_ti.get_compression() == kENCODING_DICT) {
        const auto executor = external_query_table.executor;
        const auto sdp = executor->getStringDictionaryProxy(
            col_ti.getStringDictKey(), executor->getRowSetMemoryOwner(), true);
        CHECK(sdp);
        DecodedString decoded_string;
        switch (col_ti.get_size()) {
          case 1: {
            decoded_string = decode_string<uint8_t>(column, p_cur->count - 1, sdp);
            break;
          }
          case 2: {
            decoded_string = decode_string<uint16_t>(column, p_cur->count - 1, sdp);
            break;
          }
          case 4: {
            decoded_string = decode_string<int32_t>(column, p_cur->count - 1, sdp);
            break;
          }
          default: {
            decoded_string = DecodedString{};
            LOG(FATAL) << "Invalid encoding size: " << col_ti.get_size();
          }
        }
        if (decoded_string.is_null) {
          sqlite3_result_null(ctx);
        } else {
          sqlite3_result_text(
              ctx, decoded_string.payload.first, decoded_string.payload.second, nullptr);
        }
      } else {
        CHECK(col_ti.get_compression() == kENCODING_NONE);
        const auto chunk_iter =
            const_cast<ChunkIter*>(reinterpret_cast<const ChunkIter*>(column));
        VarlenDatum vd;
        bool is_end;
        ChunkIter_get_nth(chunk_iter, p_cur->count - 1, false, &vd, &is_end);
        if (vd.is_null) {
          sqlite3_result_null(ctx);
        } else {
          sqlite3_result_text(
              ctx, reinterpret_cast<const char*>(vd.pointer), vd.length, nullptr);
        }
      }
      break;
    }
    default: {
      LOG(FATAL) << "Unexpected type: " << col_ti.get_type_name();
      break;
    }
  }
  CHECK_LE(p_cur->count, num_rows);

  return SQLITE_OK;
}

Here is the call graph for this function:

int anonymous_namespace{ExternalExecutor.cpp}::vt_connect	(	sqlite3 *	db,
		void *	p_aux,
		int	argc,
		const char *const *	argv,
		sqlite3_vtab **	pp_vt,
		char **	pzErr
	)

Definition at line 86 of file ExternalExecutor.cpp.

References vt_create().

                             {
  return vt_create(db, p_aux, argc, argv, pp_vt, pzErr);
}

Here is the call graph for this function:

int anonymous_namespace{ExternalExecutor.cpp}::vt_create	(	sqlite3 *	db,
		void *	p_aux,
		int	argc,
		const char *const *	argv,
		sqlite3_vtab **	pp_vt,
		char **	pzErr
	)

Definition at line 45 of file ExternalExecutor.cpp.

References anonymous_namespace{ExternalExecutor.cpp}::OmniSciVtab::db, join(), shared::transform(), and vt_destructor().

Referenced by vt_connect().

                            {
  // Allocate the sqlite3_vtab/OmniSciVtab structure itself.
  auto p_vt = static_cast<OmniSciVtab*>(sqlite3_malloc(sizeof(OmniSciVtab)));
  if (!p_vt) {
    return SQLITE_NOMEM;
  }

  p_vt->db = db;
  p_vt->external_query_table = reinterpret_cast<const ExternalQueryTable*>(p_aux);

  std::vector<std::string> col_defs;
  std::transform(p_vt->external_query_table->schema.begin(),
                 p_vt->external_query_table->schema.end(),
                 std::back_inserter(col_defs),
                 [](const TargetMetaInfo& target_metainfo) {
                   return target_metainfo.get_resname() + " " +
                          target_metainfo.get_type_info().get_type_name();
                 });
  const auto col_defs_str = boost::algorithm::join(col_defs, ", ");
  const auto create_statement =
      "create table vtable (" + (col_defs_str.empty() ? "dummy int" : col_defs_str) + ")";

  // Declare the vtable's structure.
  int rc = sqlite3_declare_vtab(db, create_statement.c_str());

  if (rc != SQLITE_OK) {
    vt_destructor(reinterpret_cast<sqlite3_vtab*>(p_vt));
    return SQLITE_ERROR;
  }

  // Success. Set *pp_vt and return.
  *pp_vt = &p_vt->base;

  return SQLITE_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int anonymous_namespace{ExternalExecutor.cpp}::vt_destroy

(

sqlite3_vtab *

pVtab

)

Definition at line 99 of file ExternalExecutor.cpp.

References vt_destructor().

                                    {
  int rc = SQLITE_OK;

  if (rc == SQLITE_OK) {
    rc = vt_destructor(pVtab);
  }

  return rc;
}

Here is the call graph for this function:

int anonymous_namespace{ExternalExecutor.cpp}::vt_destructor

(

sqlite3_vtab *

pVtab

)

Definition at line 38 of file ExternalExecutor.cpp.

Referenced by vt_create(), vt_destroy(), and vt_disconnect().

                                       {
  OmniSciVtab* p = reinterpret_cast<OmniSciVtab*>(pVtab);
  sqlite3_free(p);

  return 0;
}

Here is the caller graph for this function:

int anonymous_namespace{ExternalExecutor.cpp}::vt_disconnect

(

sqlite3_vtab *

pVtab

)

Definition at line 95 of file ExternalExecutor.cpp.

References vt_destructor().

                                       {
  return vt_destructor(pVtab);
}

Here is the call graph for this function:

int anonymous_namespace{ExternalExecutor.cpp}::vt_eof

(

sqlite3_vtab_cursor *

cur

)

Definition at line 123 of file ExternalExecutor.cpp.

References report::cur.

                                     {
  return reinterpret_cast<OmniSciCursor*>(cur)->eof;
}

int anonymous_namespace{ExternalExecutor.cpp}::vt_filter	(	sqlite3_vtab_cursor *	p_vtc,
		int	idxNum,
		const char *	idxStr,
		int	argc,
		sqlite3_value **	argv
	)

Definition at line 302 of file ExternalExecutor.cpp.

References anonymous_namespace{ExternalExecutor.cpp}::OmniSciCursor::count, and vt_next().

                                    {
  // Initialize the cursor structure.
  auto p_cur = reinterpret_cast<OmniSciCursor*>(p_vtc);
  // Zero rows returned thus far.
  p_cur->count = 0;
  // Have not reached end of set.
  p_cur->eof = 0;
  // Move cursor to first row.
  return vt_next(p_vtc);
}

Here is the call graph for this function:

int anonymous_namespace{ExternalExecutor.cpp}::vt_next

(

sqlite3_vtab_cursor *

cur

)

Definition at line 134 of file ExternalExecutor.cpp.

References report::cur, and get_num_rows().

Referenced by vt_filter().

                                      {
  auto p_cur = reinterpret_cast<OmniSciCursor*>(cur);
  const auto num_rows = get_num_rows(p_cur);

  if (p_cur->count == num_rows) {
    p_cur->eof = 1;
  }

  // Increment the current row count.
  ++p_cur->count;

  return SQLITE_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int anonymous_namespace{ExternalExecutor.cpp}::vt_open	(	sqlite3_vtab *	pVTab,
		sqlite3_vtab_cursor **	pp_cursor
	)

Definition at line 109 of file ExternalExecutor.cpp.

                                                                  {
  auto p_cur = static_cast<OmniSciCursor*>(sqlite3_malloc(sizeof(OmniSciCursor)));
  *pp_cursor = reinterpret_cast<sqlite3_vtab_cursor*>(p_cur);

  return (p_cur ? SQLITE_OK : SQLITE_NOMEM);
}

int anonymous_namespace{ExternalExecutor.cpp}::vt_rowid	(	sqlite3_vtab_cursor *	cur,
		sqlite_int64 *	p_rowid
	)

Definition at line 295 of file ExternalExecutor.cpp.

References anonymous_namespace{ExternalExecutor.cpp}::OmniSciCursor::count, and report::cur.

                                                              {
  auto p_cur = reinterpret_cast<OmniSciCursor*>(cur);
  // Just use the current row count as the rowid.
  *p_rowid = p_cur->count;
  return SQLITE_OK;
}

Variable Documentation

sqlite3_module anonymous_namespace{ExternalExecutor.cpp}::omnisci_module

Initial value:

= {
    0,              
    vt_create,      
    vt_connect,     
    vt_best_index,  
    vt_disconnect,  
    vt_destroy,     
    vt_open,        
    vt_close,       
    vt_filter,      
    vt_next,        
    vt_eof,         
    vt_column,      
    vt_rowid,       
    nullptr,        
    nullptr,        
    nullptr,        
    nullptr,        
    nullptr,        
    nullptr,        
    nullptr,        
    nullptr,        
    nullptr,        
    nullptr         
}

Definition at line 322 of file ExternalExecutor.cpp.

Referenced by SqliteMemDatabase::SqliteMemDatabase().