SqliteMemDatabase Class Reference

#include <ExternalExecutor.h>

Collaboration diagram for SqliteMemDatabase:

Public Member Functions
	SqliteMemDatabase (const ExternalQueryTable &external_query_table)
	~SqliteMemDatabase ()
void	run (const std::string &sql)
std::unique_ptr< ResultSet >	runSelect (const std::string &sql, const ExternalQueryOutputSpec &output_spec)

Private Attributes
sqlite3 *	db_
ExternalQueryTable	external_query_table_

Static Private Attributes
static std::mutex	session_mutex_

Detailed Description

Definition at line 48 of file ExternalExecutor.h.

Constructor & Destructor Documentation

SqliteMemDatabase::SqliteMemDatabase

(

const ExternalQueryTable &

external_query_table

)

Definition at line 384 of file ExternalExecutor.cpp.

References CHECK_EQ, db_, external_query_table_, and anonymous_namespace{ExternalExecutor.cpp}::omnisci_module.

    : external_query_table_(external_query_table) {
  int status = sqlite3_open(":memory:", &db_);
  CHECK_EQ(status, SQLITE_OK);
  status = sqlite3_create_module(db_, "omnisci", &omnisci_module, &external_query_table_);
  CHECK_EQ(status, SQLITE_OK);
}

SqliteMemDatabase::~SqliteMemDatabase

(

)

Definition at line 392 of file ExternalExecutor.cpp.

References CHECK_EQ, db_, and session_mutex_.

                                      {
  std::lock_guard session_lock(session_mutex_);
  int status = sqlite3_close(db_);
  CHECK_EQ(status, SQLITE_OK);
}

Member Function Documentation

void SqliteMemDatabase::run

(

const std::string &

sql

)

Definition at line 398 of file ExternalExecutor.cpp.

References CHECK_EQ, db_, and session_mutex_.

Referenced by run_query_external().

                                                {
  std::lock_guard session_lock(session_mutex_);
  char* msg;
  int status = sqlite3_exec(db_, sql.c_str(), nullptr, nullptr, &msg);
  CHECK_EQ(status, SQLITE_OK);
}

Here is the caller graph for this function:

std::unique_ptr< ResultSet > SqliteMemDatabase::runSelect	(	const std::string &	sql,
		const ExternalQueryOutputSpec &	output_spec
	)

Definition at line 419 of file ExternalExecutor.cpp.

References CHECK, CHECK_EQ, SqliteConnector::columnTypes, CPU, db_, ExternalQueryOutputSpec::executor, logger::FATAL, get_scan_output_slot(), SqliteConnector::getData(), SqliteConnector::getNumCols(), SqliteConnector::getNumRows(), inline_fp_null_value< double >(), inline_fp_null_value< float >(), inline_int_max_min(), inline_int_null_val(), SqliteConnector::isNull(), kBIGINT, kBOOLEAN, kCHAR, kDOUBLE, kFLOAT, kINT, kSMALLINT, kTEXT, kTINYINT, kVARCHAR, LOG, SqliteConnector::query(), ExternalQueryOutputSpec::query_mem_desc, query_mem_desc, and ExternalQueryOutputSpec::target_infos.

Referenced by run_query_external().

                                                {
  SqliteConnector connector(db_);
  connector.query(sql);
  auto query_mem_desc = output_spec.query_mem_desc;
  const auto num_rows = connector.getNumRows();
  query_mem_desc.setEntryCount(num_rows);
  auto rs = std::make_unique<ResultSet>(output_spec.target_infos,
                                        ExecutorDeviceType::CPU,
                                        query_mem_desc,
                                        output_spec.executor->getRowSetMemoryOwner(),
                                        0,
                                        0);
  const auto storage = rs->allocateStorage();
  auto output_buffer = storage->getUnderlyingBuffer();
  CHECK(!num_rows || output_buffer);
  for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {
    auto row = get_scan_output_slot(reinterpret_cast<int64_t*>(output_buffer),
                                    num_rows,
                                    row_idx,
                                    query_mem_desc.getRowSize() / sizeof(int64_t));
    CHECK_EQ(output_spec.target_infos.size(), connector.getNumCols());
    size_t slot_idx = 0;
    for (size_t col_idx = 0; col_idx < connector.getNumCols(); ++col_idx, ++slot_idx) {
      const auto& col_type = output_spec.target_infos[col_idx].sql_type;
      const int sqlite_col_type = connector.columnTypes[col_idx];
      switch (col_type.get_type()) {
        case kBOOLEAN:
        case kTINYINT:
        case kSMALLINT:
        case kINT:
        case kBIGINT: {
          static const std::string overflow_message{"Overflow or underflow"};
          if (sqlite_col_type != SQLITE_INTEGER && sqlite_col_type != SQLITE_NULL) {
            throw std::runtime_error(overflow_message);
          }
          if (!connector.isNull(row_idx, col_idx)) {
            const auto limits = inline_int_max_min(col_type.get_logical_size());
            const auto val = connector.getData<int64_t>(row_idx, col_idx);
            if (val > limits.first || val < limits.second) {
              throw std::runtime_error(overflow_message);
            }
            row[slot_idx] = val;
          } else {
            row[slot_idx] = inline_int_null_val(col_type);
          }
          break;
        }
        case kFLOAT: {
          CHECK(sqlite_col_type == SQLITE_FLOAT || sqlite_col_type == SQLITE_NULL);
          if (!connector.isNull(row_idx, col_idx)) {
            reinterpret_cast<double*>(row)[slot_idx] =
                connector.getData<double>(row_idx, col_idx);
          } else {
            reinterpret_cast<double*>(row)[slot_idx] = inline_fp_null_value<float>();
          }
          break;
        }
        case kDOUBLE: {
          CHECK(sqlite_col_type == SQLITE_FLOAT || sqlite_col_type == SQLITE_NULL);
          if (!connector.isNull(row_idx, col_idx)) {
            reinterpret_cast<double*>(row)[slot_idx] =
                connector.getData<double>(row_idx, col_idx);
          } else {
            reinterpret_cast<double*>(row)[slot_idx] = inline_fp_null_value<double>();
          }
          break;
        }
        case kCHAR:
        case kTEXT:
        case kVARCHAR: {
          CHECK(sqlite_col_type == SQLITE_TEXT || sqlite_col_type == SQLITE_NULL);
          if (!connector.isNull(row_idx, col_idx)) {
            const auto str = connector.getData<std::string>(row_idx, col_idx);
            const auto owned_str =
                output_spec.executor->getRowSetMemoryOwner()->addString(str);
            row[slot_idx] = reinterpret_cast<int64_t>(owned_str->c_str());
            row[++slot_idx] = str.size();
          } else {
            row[slot_idx] = 0;
            row[++slot_idx] = 0;
          }
          break;
        }
        default: {
          LOG(FATAL) << "Unexpected type: " << col_type.get_type_name();
          break;
        }
      }
    }
  }
  return rs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

sqlite3* SqliteMemDatabase::db_

private

Definition at line 59 of file ExternalExecutor.h.

Referenced by run(), runSelect(), SqliteMemDatabase(), and ~SqliteMemDatabase().

ExternalQueryTable SqliteMemDatabase::external_query_table_

private

Definition at line 60 of file ExternalExecutor.h.

Referenced by SqliteMemDatabase().

std::mutex SqliteMemDatabase::session_mutex_

staticprivate

Definition at line 61 of file ExternalExecutor.h.

Referenced by run(), and ~SqliteMemDatabase().

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ExternalExecutor.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ExternalExecutor.cpp