duckdb 0.3.2-dev579.0 → 0.3.2-dev589.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev579.0",
+  "version": "0.3.2-dev589.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -102046,6 +102046,25 @@ void ClientContext::TryBindRelation(Relation &relation, vector<ColumnDefinition>
 	});
 }
 
+unordered_set<string> ClientContext::GetTableNames(const string &query) {
+	auto lock = LockContext();
+
+	auto statements = ParseStatementsInternal(*lock, query);
+	if (statements.size() != 1) {
+		throw InvalidInputException("Expected a single statement");
+	}
+
+	unordered_set<string> result;
+	RunFunctionInTransactionInternal(*lock, [&]() {
+		// bind the expressions
+		auto binder = Binder::CreateBinder(*this);
+		binder->SetBindingMode(BindingMode::EXTRACT_NAMES);
+		binder->Bind(*statements[0]);
+		result = binder->GetTableNames();
+	});
+	return result;
+}
+
 unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relation) {
 	auto lock = LockContext();
 	InitialCleanup(*lock);
@@ -103004,6 +103023,10 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<st
 	return make_shared<ReadCSVRelation>(*context, csv_file, move(column_list));
 }
 
+unordered_set<string> Connection::GetTableNames(const string &query) {
+	return context->GetTableNames(query);
+}
+
 shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const string &alias) {
 	return make_shared<QueryRelation>(*context, query, alias);
 }
@@ -145427,6 +145450,7 @@ private:
 
 
 
+
 namespace duckdb {
 
 unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &column_name, string &error_message) {
@@ -145589,6 +145613,9 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpres
 }
 
 BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t depth) {
+	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
+		return BindResult(make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
+	}
 	string error_message;
 	auto expr = QualifyColumnName(colref_p, error_message);
 	if (!expr) {
@@ -145850,6 +145877,10 @@ BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFu
 	if (!error.empty()) {
 		return BindResult(error);
 	}
+	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
+		return BindResult(make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
+	}
+
 	// all children bound successfully
 	// extract the children and types
 	vector<unique_ptr<Expression>> children;
@@ -149981,6 +150012,29 @@ public:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/tableref/bound_dummytableref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//! Represents a cross product
+class BoundEmptyTableRef : public BoundTableRef {
+public:
+	explicit BoundEmptyTableRef(idx_t bind_index) : BoundTableRef(TableReferenceType::EMPTY), bind_index(bind_index) {
+	}
+	idx_t bind_index;
+};
+} // namespace duckdb
+
 
 namespace duckdb {
 
@@ -150044,6 +150098,19 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 				return Bind(*replacement_function);
 			}
 		}
+		// we still didn't find the table
+		if (GetBindingMode() == BindingMode::EXTRACT_NAMES) {
+			// if we are in EXTRACT_NAMES, we create a dummy table ref
+			AddTableName(ref.table_name);
+
+			// add a bind context entry
+			auto table_index = GenerateTableIndex();
+			auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
+			vector<LogicalType> types {LogicalType::INTEGER};
+			vector<string> names {"__dummy_col" + to_string(table_index)};
+			bind_context.AddGenericBinding(table_index, alias, names, types);
+			return make_unique_base<BoundTableRef, BoundEmptyTableRef>(table_index);
+		}
 		// could not find an alternative: bind again to get the error
 		table_or_view = Catalog::GetCatalog(context).GetEntry(context, CatalogType::TABLE_ENTRY, ref.schema_name,
 		                                                      ref.table_name, false, error_context);
@@ -150126,28 +150193,6 @@ unique_ptr<BoundTableRef> Binder::Bind(CrossProductRef &ref) {
 } // namespace duckdb
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_dummytableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a cross product
-class BoundEmptyTableRef : public BoundTableRef {
-public:
-	explicit BoundEmptyTableRef(idx_t bind_index) : BoundTableRef(TableReferenceType::EMPTY), bind_index(bind_index) {
-	}
-	idx_t bind_index;
-};
-} // namespace duckdb
 
 
 namespace duckdb {
@@ -151406,6 +151451,35 @@ bool Binder::HasMatchingBinding(const string &schema_name, const string &table_n
 	return true;
 }
 
+void Binder::SetBindingMode(BindingMode mode) {
+	if (parent) {
+		parent->SetBindingMode(mode);
+	}
+	this->mode = mode;
+}
+
+BindingMode Binder::GetBindingMode() {
+	if (parent) {
+		return parent->GetBindingMode();
+	}
+	return mode;
+}
+
+void Binder::AddTableName(string table_name) {
+	if (parent) {
+		parent->AddTableName(move(table_name));
+		return;
+	}
+	table_names.insert(move(table_name));
+}
+
+const unordered_set<string> &Binder::GetTableNames() {
+	if (parent) {
+		return parent->GetTableNames();
+	}
+	return table_names;
+}
+
 string Binder::FormatError(ParsedExpression &expr_context, const string &message) {
 	return FormatError(expr_context.query_location, message);
 }

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "5819f9836"
-#define DUCKDB_VERSION "0.3.2-dev579"
+#define DUCKDB_SOURCE_ID "43cae15ac"
+#define DUCKDB_VERSION "0.3.2-dev589"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -9621,6 +9621,9 @@ public:
 	DUCKDB_API void SetAutoCommit(bool auto_commit);
 	DUCKDB_API bool IsAutoCommit();
 
+	//! Fetch a list of table names that are required for a given query
+	DUCKDB_API unordered_set<string> GetTableNames(const string &query);
+
 	template <typename TR, typename... Args>
 	void CreateScalarFunction(const string &name, TR (*udf_func)(Args...)) {
 		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, Args...>(name, udf_func);
@@ -14683,6 +14686,8 @@ struct BoundCreateTableInfo;
 struct BoundCreateFunctionInfo;
 struct CommonTableExpressionInfo;
 
+enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES };
+
 struct CorrelatedColumnInfo {
 	ColumnBinding binding;
 	LogicalType type;
@@ -14797,6 +14802,11 @@ public:
 	bool HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
 	                        string &error_message);
 
+	void SetBindingMode(BindingMode mode);
+	BindingMode GetBindingMode();
+	void AddTableName(string table_name);
+	const unordered_set<string> &GetTableNames();
+
 private:
 	//! The parent binder (if any)
 	shared_ptr<Binder> parent;
@@ -14814,6 +14824,10 @@ private:
 	bool can_contain_nulls = false;
 	//! The root statement of the query that is currently being parsed
 	SQLStatement *root_statement = nullptr;
+	//! Binding mode
+	BindingMode mode = BindingMode::STANDARD_BINDING;
+	//! Table names extracted for BindingMode::EXTRACT_NAMES
+	unordered_set<string> table_names;
 
 private:
 	//! Bind the default values of the columns of a table
@@ -17025,6 +17039,9 @@ public:
 	//! Equivalent to CURRENT_SETTING(key) SQL function.
 	DUCKDB_API bool TryGetCurrentSetting(const std::string &key, Value &result);
 
+	//! Fetch a list of table names that are required for a given query
+	DUCKDB_API unordered_set<string> GetTableNames(const string &query);
+
 private:
 	//! Parse statements from a query
 	vector<unique_ptr<SQLStatement>> ParseStatementsInternal(ClientContextLock &lock, const string &query);