duckdb 0.3.1-dev631.0 → 0.3.1-dev657.0

package/package.json

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

package/src/duckdb.cpp

@@ -102251,11 +102251,16 @@ namespace duckdb {
 
 class TableFunctionRelation : public Relation {
 public:
+	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
+	                      unordered_map<string, Value> named_parameters,
+	                      shared_ptr<Relation> input_relation_p = nullptr);
+
 	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
 	                      shared_ptr<Relation> input_relation_p = nullptr);
 
 	string name;
 	vector<Value> parameters;
+	unordered_map<string, Value> named_parameters;
 	vector<ColumnDefinition> columns;
 	shared_ptr<Relation> input_relation;
 
@@ -102523,7 +102528,13 @@ shared_ptr<Relation> Connection::View(const string &schema_name, const string &t
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname) {
 	vector<Value> values;
-	return TableFunction(fname, values);
+	unordered_map<string, Value> named_parameters;
+	return TableFunction(fname, values, named_parameters);
+}
+
+shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values,
+                                               const unordered_map<string, Value> &named_parameters) {
+	return make_shared<TableFunctionRelation>(*context, fname, values, named_parameters);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values) {
@@ -102672,6 +102683,33 @@ private:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/extension_helper.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <string>
+
+
+namespace duckdb {
+class DuckDB;
+
+enum class ExtensionLoadResult : uint8_t { LOADED_EXTENSION = 0, EXTENSION_UNKNOWN = 1, NOT_LOADED = 2 };
+
+class ExtensionHelper {
+public:
+	static void LoadAllExtensions(DuckDB &db);
+
+	static ExtensionLoadResult LoadExtension(DuckDB &db, const std::string &extension);
+};
+
+} // namespace duckdb
+
 
 #ifndef DUCKDB_NO_THREADS
 
@@ -102797,6 +102835,9 @@ void DatabaseInstance::Initialize(const char *path, DBConfig *new_config) {
 
 DuckDB::DuckDB(const char *path, DBConfig *new_config) : instance(make_shared<DatabaseInstance>()) {
 	instance->Initialize(path, new_config);
+	if (instance->config.load_extensions) {
+		ExtensionHelper::LoadAllExtensions(*this);
+	}
 }
 
 DuckDB::DuckDB(const string &path, DBConfig *config) : DuckDB(path.c_str(), config) {
@@ -102868,6 +102909,7 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 	} else {
 		config.maximum_threads = new_config.maximum_threads;
 	}
+	config.load_extensions = new_config.load_extensions;
 	config.force_compression = new_config.force_compression;
 	config.allocator = move(new_config.allocator);
 	config.checkpoint_wal_size = new_config.checkpoint_wal_size;
@@ -102897,6 +102939,102 @@ idx_t DuckDB::NumberOfThreads() {
 } // namespace duckdb
 
 
+#ifdef BUILD_ICU_EXTENSION
+#include "icu-extension.hpp"
+#endif
+
+#ifdef BUILD_PARQUET_EXTENSION
+#include "parquet-extension.hpp"
+#endif
+
+#ifdef BUILD_TPCH_EXTENSION
+#include "tpch-extension.hpp"
+#endif
+
+#ifdef BUILD_TPCDS_EXTENSION
+#include "tpcds-extension.hpp"
+#endif
+
+#ifdef BUILD_FTS_EXTENSION
+#include "fts-extension.hpp"
+#endif
+
+#ifdef BUILD_HTTPFS_EXTENSION
+#include "httpfs-extension.hpp"
+#endif
+
+#ifdef BUILD_VISUALIZER_EXTENSION
+#include "visualizer-extension.hpp"
+#endif
+
+namespace duckdb {
+
+void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
+	unordered_set<string> extensions {"parquet", "icu", "tpch", "tpcds", "fts", "httpfs", "visualizer"};
+	for (auto &ext : extensions) {
+		LoadExtension(db, ext);
+	}
+}
+
+ExtensionLoadResult ExtensionHelper::LoadExtension(DuckDB &db, const std::string &extension) {
+	if (extension == "parquet") {
+#ifdef BUILD_PARQUET_EXTENSION
+		db.LoadExtension<ParquetExtension>();
+#else
+		// parquet extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "icu") {
+#ifdef BUILD_ICU_EXTENSION
+		db.LoadExtension<ICUExtension>();
+#else
+		// icu extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "tpch") {
+#ifdef BUILD_TPCH_EXTENSION
+		db.LoadExtension<TPCHExtension>();
+#else
+		// icu extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "tpcds") {
+#ifdef BUILD_TPCDS_EXTENSION
+		db.LoadExtension<TPCDSExtension>();
+#else
+		// icu extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "fts") {
+#ifdef BUILD_FTS_EXTENSION
+		db.LoadExtension<FTSExtension>();
+#else
+		// fts extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "httpfs") {
+#ifdef BUILD_HTTPFS_EXTENSION
+		db.LoadExtension<HTTPFsExtension>();
+#else
+		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "visualizer") {
+#ifdef BUILD_VISUALIZER_EXTENSION
+		db.LoadExtension<VisualizerExtension>();
+#else
+		// visualizer extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else {
+		// unknown extension
+		return ExtensionLoadResult::EXTENSION_UNKNOWN;
+	}
+	return ExtensionLoadResult::LOADED_EXTENSION;
+}
+
+} // namespace duckdb
+
+
 
 namespace duckdb {
 
@@ -105615,9 +105753,19 @@ public:
 
 
 
+
+
 namespace duckdb {
 
 TableFunctionRelation::TableFunctionRelation(ClientContext &context, string name_p, vector<Value> parameters_p,
+                                             unordered_map<string, Value> named_parameters,
+                                             shared_ptr<Relation> input_relation_p)
+    : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
+      named_parameters(move(named_parameters)), input_relation(move(input_relation_p)) {
+	context.TryBindRelation(*this, this->columns);
+}
+TableFunctionRelation::TableFunctionRelation(ClientContext &context, string name_p, vector<Value> parameters_p,
+
                                              shared_ptr<Relation> input_relation_p)
     : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
       input_relation(move(input_relation_p)) {
@@ -105644,6 +105792,17 @@ unique_ptr<TableRef> TableFunctionRelation::GetTableRef() {
 		children.push_back(make_unique<ConstantExpression>(parameter));
 	}
 
+	for (auto &parameter : named_parameters) {
+		// Hackity-hack some comparisons with column refs
+		// This is all but pretty, basically the named parameter is the column, the table is empty because that's what
+		// the function binder likes
+		auto column_ref = make_unique<ColumnRefExpression>(parameter.first);
+		auto constant_value = make_unique<ConstantExpression>(parameter.second);
+		auto comparison =
+		    make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, move(column_ref), move(constant_value));
+		children.push_back(move(comparison));
+	}
+
 	auto table_function = make_unique<TableFunctionRef>();
 	auto function = make_unique<FunctionExpression>(name, move(children));
 	table_function->function = move(function);
@@ -106388,6 +106547,11 @@ void Relation::Delete(const string &condition) {
 	throw Exception("DELETE can only be used on base tables!");
 }
 
+shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values,
+                                             const unordered_map<string, Value> &named_parameters) {
+	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters, shared_from_this());
+}
+
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values) {
 	return make_shared<TableFunctionRelation>(context, fname, values, shared_from_this());
 }

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 "1d4d32326"
-#define DUCKDB_VERSION "0.3.1-dev631"
+#define DUCKDB_SOURCE_ID "0385e028a"
+#define DUCKDB_VERSION "0.3.1-dev657"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -9228,6 +9228,7 @@ string RelationTypeToString(RelationType type);
 
 
 
+
 #include <memory>
 
 namespace duckdb {
@@ -9331,7 +9332,10 @@ public:
 	//! Delete from a table, can only be used on a TableRelation
 	DUCKDB_API virtual void Delete(const string &condition = string());
 	//! Create a relation from calling a table in/out function on the input relation
+	//! Create a relation from calling a table in/out function on the input relation
 	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values);
+	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values,
+	                                              const unordered_map<string, Value> &named_parameters);
 
 public:
 	//! Whether or not the relation inherits column bindings from its child or not, only relevant for binding
@@ -9574,6 +9578,8 @@ public:
 	DUCKDB_API shared_ptr<Relation> View(const string &schema_name, const string &table_name);
 	//! Returns a relation that calls a specified table function
 	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname);
+	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values,
+	                                              const unordered_map<string, Value> &named_parameters);
 	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values);
 	//! Returns a relation that produces values
 	DUCKDB_API shared_ptr<Relation> Values(const vector<vector<Value>> &values);
@@ -10107,6 +10113,8 @@ public:
 	idx_t checkpoint_wal_size = 1 << 24;
 	//! Whether or not to use Direct IO, bypassing operating system buffers
 	bool use_direct_io = false;
+	//! Whether extensions should be loaded on start-up
+	bool load_extensions = true;
 	//! The FileSystem to use, can be overwritten to allow for injecting custom file systems for testing purposes (e.g.
 	//! RamFS or something similar)
 	unique_ptr<FileSystem> file_system;