Use raw pointers for schema provider and config when passed to Calcite

Expect higher layers to handle lifetime management of these objects

Author: alexbaden

omniscidb/Calcite/CalciteJNI.cpp

@@ -201,8 +201,8 @@ class CalciteJNI {
 
   std::string process(const std::string& db_name,
                       const std::string& sql_string,
-                      SchemaProviderPtr schema_provider,
-                      ConfigPtr config,
+                      SchemaProvider* schema_provider,
+                      Config* config,
                       const std::vector<FilterPushDownInfo>& filter_push_down_info,
                       const bool legacy_syntax,
                       const bool is_explain,
@@ -575,8 +575,8 @@ CalciteMgr::~CalciteMgr() {
 std::string CalciteMgr::process(
     const std::string& db_name,
     const std::string& sql_string,
-    SchemaProviderPtr schema_provider,
-    ConfigPtr config,
+    SchemaProvider* schema_provider,
+    Config* config,
     const std::vector<FilterPushDownInfo>& filter_push_down_info,
     const bool legacy_syntax,
     const bool is_explain,

omniscidb/Calcite/CalciteJNI.h

@@ -53,8 +53,8 @@ class CalciteMgr {
 
   std::string process(const std::string& db_name,
                       const std::string& sql_string,
-                      SchemaProviderPtr schema_provider,
-                      ConfigPtr config,
+                      SchemaProvider* schema_provider,
+                      Config* config,
                       const std::vector<FilterPushDownInfo>& filter_push_down_info = {},
                       const bool legacy_syntax = false,
                       const bool is_explain = false,

omniscidb/Calcite/SchemaJson.cpp

@@ -183,7 +183,7 @@ int getCalciteScale(const hdk::ir::Type* type) {
 
 }  // namespace
 
-std::string schema_to_json(SchemaProviderPtr schema_provider) {
+std::string schema_to_json(SchemaProvider* schema_provider) {
   auto dbs = schema_provider->listDatabases();
   if (dbs.empty()) {
     return "{}";

omniscidb/Calcite/SchemaJson.h

@@ -14,4 +14,4 @@
 
 #include "SchemaMgr/SchemaProvider.h"
 
-std::string schema_to_json(SchemaProviderPtr schema_provider);
+std::string schema_to_json(SchemaProvider* schema_provider);

omniscidb/Tests/ArrowSQLRunner/RelAlgCache.cpp

@@ -61,7 +61,7 @@ std::string RelAlgCache::process(
 
   std::string schema_json;
   if (!use_cache_.empty() || !build_cache_.empty()) {
-    schema_json = schema_to_json(schema_provider_);
+    schema_json = schema_to_json(schema_provider_.get());
   }
 
   if (!use_cache_.empty()) {
@@ -89,8 +89,8 @@ std::string RelAlgCache::process(
 
   auto ra = calcite_->process(db_name,
                               sql_string,
-                              schema_provider_,
-                              config_,
+                              schema_provider_.get(),
+                              config_.get(),
                               filter_push_down_info,
                               legacy_syntax,
                               is_explain,

omniscidb/Tests/NoCatalogSqlTest.cpp

@@ -162,12 +162,14 @@ class NoCatalogSqlTest : public ::testing::Test {
   }
 
   ExecutionResult runSqlQuery(const std::string& sql, Executor* executor) {
-    const auto query_ra = calcite_->process("test_db", sql, schema_provider_, config_);
+    const auto query_ra =
+        calcite_->process("test_db", sql, schema_provider_.get(), config_.get());
     return runRAQuery(query_ra, executor);
   }
 
   RelAlgExecutor getExecutor(const std::string& sql) {
-    const auto query_ra = calcite_->process("test_db", sql, schema_provider_, config_);
+    const auto query_ra =
+        calcite_->process("test_db", sql, schema_provider_.get(), config_.get());
     auto dag = std::make_unique<RelAlgDagBuilder>(
         query_ra, TEST_DB_ID, schema_provider_, config_);
     return RelAlgExecutor(executor_.get(), schema_provider_, std::move(dag));
@@ -234,7 +236,7 @@ TEST_F(NoCatalogSqlTest, GroupBySingleColumn) {
 }
 
 TEST_F(NoCatalogSqlTest, MultipleCalciteMultipleThreads) {
-  constexpr size_t TEST_NTHREADS = 1000;
+  constexpr size_t TEST_NTHREADS = 100;
   std::vector<ExecutionResult> res;
   std::vector<std::future<void>> threads;
   res.resize(TEST_NTHREADS);
@@ -252,8 +254,8 @@ TEST_F(NoCatalogSqlTest, MultipleCalciteMultipleThreads) {
                              &res,
                              &executors,
                              calcite,
-                             schema_provider = schema_provider_,
-                             config = config_]() {
+                             schema_provider = schema_provider_.get(),
+                             config = config_.get()]() {
                               auto query_ra = calcite->process(
                                   "test_db",
                                   "SELECT col_bi + " + std::to_string(i) + " FROM test1;",
@@ -279,7 +281,8 @@ TEST(CalciteReinitTest, SingleThread) {
   auto config = std::make_shared<Config>();
   for (int i = 0; i < 10; ++i) {
     auto calcite = CalciteMgr::get();
-    auto query_ra = calcite->process("test_db", "SELECT 1;", schema_provider, config);
+    auto query_ra =
+        calcite->process("test_db", "SELECT 1;", schema_provider.get(), config.get());
     CHECK(query_ra.find("LogicalValues") != std::string::npos) << query_ra;
   }
 }
@@ -290,7 +293,8 @@ TEST(CalciteReinitTest, MultipleThreads) {
   for (int i = 0; i < 10; ++i) {
     auto f = std::async(std::launch::async, [schema_provider, config]() {
       auto calcite = CalciteMgr::get();
-      auto query_ra = calcite->process("test_db", "SELECT 1;", schema_provider, config);
+      auto query_ra =
+          calcite->process("test_db", "SELECT 1;", schema_provider.get(), config.get());
       CHECK(query_ra.find("LogicalValues") != std::string::npos) << query_ra;
     });
     f.wait();

python/pyhdk/_sql.pxd

@@ -9,7 +9,7 @@ from libcpp.string cimport string
 from libcpp.vector cimport vector
 
 from pyhdk._common cimport CConfig
-from pyhdk._storage cimport CSchemaProviderPtr, CDataProvider, CDataMgr, CBufferProvider
+from pyhdk._storage cimport CSchemaProvider, CSchemaProviderPtr, CDataProvider, CDataMgr, CBufferProvider
 from pyhdk._execute cimport CExecutor, CResultSetPtr, CCompilationOptions, CExecutionOptions, CTargetMetaInfo
 
 cdef extern from "omniscidb/QueryEngine/ExtensionFunctionsWhitelist.h":
@@ -33,7 +33,7 @@ cdef extern from "omniscidb/Calcite/CalciteJNI.h":
     @staticmethod
     CalciteMgr* get(const string&, size_t);
 
-    string process(const string&, const string&, CSchemaProviderPtr, shared_ptr[CConfig], const vector[FilterPushDownInfo]&, bool, bool, bool) except +
+    string process(const string&, const string&, CSchemaProvider*, CConfig*, const vector[FilterPushDownInfo]&, bool, bool, bool) except +
 
     string getExtensionFunctionWhitelist()
     string getUserDefinedFunctionWhitelist()

python/pyhdk/_sql.pyx

@@ -40,7 +40,7 @@ cdef class Calcite:
     cdef bool legacy_syntax = kwargs.get("legacy_syntax", False)
     cdef bool is_explain = kwargs.get("is_explain", False)
     cdef bool is_view_optimize = kwargs.get("is_view_optimize", False)
-    return self.calcite.process(db_name, sql, self.schema_provider, self.config, filter_push_down_info, legacy_syntax, is_explain, is_view_optimize)
+    return self.calcite.process(db_name, sql, self.schema_provider.get(), self.config.get(), filter_push_down_info, legacy_syntax, is_explain, is_view_optimize)
 
 cdef class ExecutionResult:
   def row_count(self):

src/HDK.cpp

@@ -40,8 +40,8 @@ ExecutionResult HDK::query(const std::string& sql, const bool is_explain) {
   CHECK(internal_->calcite);
   auto ra = internal_->calcite->process(internal_->db_name,
                                         sql,
-                                        internal_->storage,
-                                        internal_->config,
+                                        internal_->storage.get(),
+                                        internal_->config.get(),
                                         {},
                                         /*legacy_syntax=*/true);