duckdb 0.6.2-dev1922.0 → 0.6.2-dev1968.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev1922.0",
+  "version": "0.6.2-dev1968.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {
@@ -19,6 +19,7 @@
     "install": "node-pre-gyp install --fallback-to-build",
     "pretest": "node test/support/createdb.js",
     "test": "mocha -R spec --timeout 480000 --expose-gc",
+    "test-path": "mocha -R spec --timeout 480000 --exclude 'test/*.ts'",
     "pack": "node-pre-gyp package"
   },
   "directories": {

package/src/database.cpp

@@ -368,8 +368,9 @@ Napi::Value Database::RegisterReplacementScan(const Napi::CallbackInfo &info) {
 		return env.Null();
 	}
 	Napi::Function rs_callback = info[0].As<Napi::Function>();
-	auto rs = duckdb_node_rs_function_t::New(env, rs_callback, "duckdb_node_rs_" + (replacement_scan_count++), 0, 1,
-	                                         nullptr, [](Napi::Env, void *, std::nullptr_t *ctx) {});
+	auto rs =
+	    duckdb_node_rs_function_t::New(env, rs_callback, "duckdb_node_rs_" + std::to_string(replacement_scan_count++),
+	                                   0, 1, nullptr, [](Napi::Env, void *, std::nullptr_t *ctx) {});
 	rs.Unref(env);
 
 	Schedule(info.Env(), duckdb::make_unique<RegisterRsTask>(*this, rs, deferred));

package/src/duckdb/src/common/operator/cast_operators.cpp

@@ -945,11 +945,13 @@ static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict)
 					ExponentData exponent {0, false};
 					int negative = buf[pos] == '-';
 					if (negative) {
-						if (!IntegerCastLoop<ExponentData, true, false>(buf + pos, len - pos, exponent, strict)) {
+						if (!IntegerCastLoop<ExponentData, true, false, IntegerCastOperation>(buf + pos, len - pos,
+						                                                                      exponent, strict)) {
 							return false;
 						}
 					} else {
-						if (!IntegerCastLoop<ExponentData, false, false>(buf + pos, len - pos, exponent, strict)) {
+						if (!IntegerCastLoop<ExponentData, false, false, IntegerCastOperation>(buf + pos, len - pos,
+						                                                                       exponent, strict)) {
 							return false;
 						}
 					}

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -151,6 +151,7 @@ void GroupedAggregateHashTable::VerifyInternal() {
 			count++;
 		}
 	}
+	(void)count;
 	D_ASSERT(count == entries);
 }
 

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -31,8 +31,8 @@ PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry *t
     : PhysicalOperator(PhysicalOperatorType::INSERT, std::move(types_p), estimated_cardinality),
       column_index_map(std::move(column_index_map)), insert_table(table), insert_types(table->GetTypes()),
       bound_defaults(std::move(bound_defaults)), return_chunk(return_chunk), parallel(parallel),
-      action_type(action_type), set_expressions(std::move(set_expressions)), set_columns(move(set_columns)),
-      set_types(move(set_types)), on_conflict_condition(std::move(on_conflict_condition_p)),
+      action_type(action_type), set_expressions(std::move(set_expressions)), set_columns(std::move(set_columns)),
+      set_types(std::move(set_types)), on_conflict_condition(std::move(on_conflict_condition_p)),
       do_update_condition(std::move(do_update_condition_p)), conflict_target(std::move(conflict_target_p)),
       columns_to_fetch(std::move(columns_to_fetch_p)) {
 

package/src/duckdb/src/function/cast/map_cast.cpp

@@ -12,7 +12,7 @@ unique_ptr<BoundCastData> MapBoundCastData::BindMapToMapCast(BindCastInput &inpu
 	auto target_val = MapType::ValueType(target);
 	auto key_cast = input.GetCastFunction(source_key, target_key);
 	auto value_cast = input.GetCastFunction(source_val, target_val);
-	return make_unique<MapBoundCastData>(move(key_cast), move(value_cast));
+	return make_unique<MapBoundCastData>(std::move(key_cast), std::move(value_cast));
 }
 
 static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev1922"
+#define DUCKDB_VERSION "0.6.2-dev1968"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "bc37e4517c"
+#define DUCKDB_SOURCE_ID "c1f2d10c78"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp

@@ -116,7 +116,7 @@ public:
 
 struct MapBoundCastData : public BoundCastData {
 	MapBoundCastData(BoundCastInfo key_cast, BoundCastInfo value_cast)
-	    : key_cast(move(key_cast)), value_cast(move(value_cast)) {
+	    : key_cast(std::move(key_cast)), value_cast(std::move(value_cast)) {
 	}
 
 	BoundCastInfo key_cast;

package/src/duckdb/src/include/duckdb/function/create_database_extension.hpp

@@ -27,7 +27,7 @@ typedef unique_ptr<TableFunctionRef> (*create_database_t)(ClientContext &context
 struct CreateDatabaseExtension {
 	explicit CreateDatabaseExtension(create_database_t function,
 	                                 unique_ptr<CreateDatabaseExtensionData> data_p = nullptr)
-	    : function(function), data(move(data_p)) {
+	    : function(function), data(std::move(data_p)) {
 	}
 
 	create_database_t function;

package/src/duckdb/src/include/duckdb/main/client_config.hpp

@@ -79,6 +79,9 @@ struct ClientConfig {
 	//! Callback to create a progress bar display
 	progress_bar_display_create_func_t display_create_func = nullptr;
 
+	//! Override for the default extension repository
+	string custom_extension_repo = "";
+
 	//! The explain output type used when none is specified (default: PHYSICAL_ONLY)
 	ExplainOutputType explain_output_type = ExplainOutputType::PHYSICAL_ONLY;
 

package/src/duckdb/src/include/duckdb/main/settings.hpp

@@ -142,6 +142,15 @@ struct AllowUnsignedExtensionsSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct CustomExtensionRepository {
+	static constexpr const char *Name = "custom_extension_repository";
+	static constexpr const char *Description = "Overrides the custom endpoint for remote extension installation";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct EnableObjectCacheSetting {
 	static constexpr const char *Name = "enable_object_cache";
 	static constexpr const char *Description = "Whether or not object cache is used to cache e.g. Parquet metadata";

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -60,7 +60,7 @@ struct ColumnScanState {
 	//! The version of the column data that we are scanning.
 	//! This is used to detect if the ColumnData has been changed out from under us during a scan
 	//! If this is the case, we re-initialize the scan
-	idx_t version;
+	idx_t version = 0;
 	//! We initialize one SegmentScanState per segment, however, if scanning a DataChunk requires us to scan over more
 	//! than one Segment, we need to keep the scan states of the previous segments around
 	vector<unique_ptr<SegmentScanState>> previous_states;

package/src/duckdb/src/main/config.cpp

@@ -59,6 +59,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(EnableExternalAccessSetting),
                                                  DUCKDB_GLOBAL(EnableFSSTVectors),
                                                  DUCKDB_GLOBAL(AllowUnsignedExtensionsSetting),
+                                                 DUCKDB_LOCAL(CustomExtensionRepository),
                                                  DUCKDB_GLOBAL(EnableObjectCacheSetting),
                                                  DUCKDB_GLOBAL(EnableHTTPMetadataCacheSetting),
                                                  DUCKDB_LOCAL(EnableProfilingSetting),

package/src/duckdb/src/main/extension/extension_helper.cpp

@@ -78,6 +78,11 @@
 #include "inet-extension.hpp"
 #endif
 
+// Load the generated header file containing our list of extension headers
+#if defined(OOTE_HEADERS_AVAILABLE) && OOTE_HEADERS_AVAILABLE
+#include "extension_oote_loader.hpp"
+#endif
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -118,6 +123,12 @@ void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 	for (auto &ext : extensions) {
 		LoadExtensionInternal(db, ext, true);
 	}
+
+#if defined(OOTE_HEADERS_AVAILABLE) && OOTE_HEADERS_AVAILABLE
+	for (auto &ext : OOT_EXTENSIONS) {
+		LoadExtensionInternal(db, ext, true);
+	}
+#endif
 }
 
 ExtensionLoadResult ExtensionHelper::LoadExtension(DuckDB &db, const std::string &extension) {
@@ -226,7 +237,12 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else {
-		// unknown extension
+
+#if defined(OOTE_HEADERS_AVAILABLE) && OOTE_HEADERS_AVAILABLE
+		if (TryLoadLinkedExtension(db, extension)) {
+			return ExtensionLoadResult::LOADED_EXTENSION;
+		}
+#endif
 		return ExtensionLoadResult::EXTENSION_UNKNOWN;
 	}
 	return ExtensionLoadResult::LOADED_EXTENSION;

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -120,7 +120,12 @@ void ExtensionHelper::InstallExtension(ClientContext &context, const string &ext
 #ifdef DISABLE_DUCKDB_REMOTE_INSTALL
 	throw BinderException("Remote extension installation is disabled through configuration");
 #else
-	string url_template = "http://extensions.duckdb.org/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
+
+	string default_endpoint = "http://extensions.duckdb.org";
+	string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
+	string &custom_endpoint = ClientConfig::GetConfig(context).custom_extension_repo;
+	string &endpoint = !custom_endpoint.empty() ? custom_endpoint : default_endpoint;
+	string url_template = endpoint + versioned_path;
 
 	if (is_http_url) {
 		url_template = extension;

package/src/duckdb/src/main/settings/settings.cpp

@@ -433,6 +433,22 @@ Value EnableProfilingSetting::GetSetting(ClientContext &context) {
 	}
 }
 
+//===--------------------------------------------------------------------===//
+// Custom Extension Repository
+//===--------------------------------------------------------------------===//
+
+void CustomExtensionRepository::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).custom_extension_repo = ClientConfig().custom_extension_repo;
+}
+
+void CustomExtensionRepository::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).custom_extension_repo = StringUtil::Lower(input.ToString());
+}
+
+Value CustomExtensionRepository::GetSetting(ClientContext &context) {
+	return Value(ClientConfig::GetConfig(context).custom_extension_repo);
+}
+
 //===--------------------------------------------------------------------===//
 // Enable Progress Bar
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/parser/transform/statement/transform_create_database.cpp

@@ -22,7 +22,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateDatabase(duckdb_libpgque
 	info->catalog = qualified_name.catalog;
 	info->name = qualified_name.name;
 
-	result->info = move(info);
+	result->info = std::move(info);
 	return result;
 }
 

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -119,7 +119,7 @@ void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert
 			throw BinderException("Expression in the DO UPDATE SET clause can not be a subquery");
 		}
 
-		insert->expressions.push_back(move(bound_expr));
+		insert->expressions.push_back(std::move(bound_expr));
 	}
 
 	// Figure out which columns are indexed on

package/src/duckdb/src/planner/binder/statement/bind_update.cpp

@@ -166,7 +166,7 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator *op, unique_pt
 
 			op->expressions.push_back(make_unique<BoundColumnRefExpression>(
 			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
-			projection_expressions.push_back(move(bound_expr));
+			projection_expressions.push_back(std::move(bound_expr));
 		}
 	}
 	if (op->type != LogicalOperatorType::LOGICAL_UPDATE && projection_expressions.empty()) {
@@ -174,8 +174,8 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator *op, unique_pt
 	}
 	// now create the projection
 	auto proj = make_unique<LogicalProjection>(proj_index, std::move(projection_expressions));
-	proj->AddChild(move(root));
-	return unique_ptr_cast<LogicalProjection, LogicalOperator>(move(proj));
+	proj->AddChild(std::move(root));
+	return unique_ptr_cast<LogicalProjection, LogicalOperator>(std::move(proj));
 }
 
 BoundStatement Binder::Bind(UpdateStatement &stmt) {

package/src/duckdb/third_party/fmt/include/fmt/core.h

@@ -356,7 +356,11 @@ using string_view = basic_string_view<char>;
 using wstring_view = basic_string_view<wchar_t>;
 
 // A UTF-8 code unit type.
+#if FMT_HAS_FEATURE(__cpp_char8_t)
+typedef char8_t fmt_char8_t;
+#else
 typedef unsigned char fmt_char8_t;
+#endif
 
 /** Specifies if ``T`` is a character type. Can be specialized by users. */
 template <typename T> struct is_char : std::false_type {};

package/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp

@@ -17415,6 +17415,7 @@ YYLTYPE yylloc;
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
+  (void)yynerrs;
   yychar = YYEMPTY;		/* Cause a token to be read.  */
 
   /* Initialize stack pointers.