duckdb 0.4.1-dev144.0 → 0.4.1-dev160.0

package/package.json

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

package/src/duckdb.cpp

@@ -45834,6 +45834,10 @@ struct StructPackFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct StructInsertFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct ListValueFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -98812,6 +98816,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ArraySliceFun>();
 	Register<StructPackFun>();
 	Register<StructExtractFun>();
+	Register<StructInsertFun>();
 	Register<ListConcatFun>();
 	Register<ListContainsFun>();
 	Register<ListPositionFun>();
@@ -104604,6 +104609,111 @@ void StructExtractFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+namespace duckdb {
+
+static void StructInsertFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &starting_vec = args.data[0];
+
+	starting_vec.Verify(args.size());
+
+	auto &starting_child_entries = StructVector::GetEntries(starting_vec);
+
+	auto &result_child_entries = StructVector::GetEntries(result);
+
+	// Assign the starting vector entries to the result vector
+	for (size_t i = 0; i < starting_child_entries.size(); i++) {
+		auto &starting_child = starting_child_entries[i];
+		result_child_entries[i]->Reference(*starting_child);
+	}
+
+	// Assign the new entries to the result vector
+	for (size_t i = 1; i < args.ColumnCount(); i++) {
+		result_child_entries[starting_child_entries.size() + i - 1]->Reference(args.data[i]);
+	}
+
+	result.Verify(args.size());
+}
+
+static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarFunction &bound_function,
+                                                 vector<unique_ptr<Expression>> &arguments) {
+	case_insensitive_set_t name_collision_set;
+
+	if (arguments.empty()) {
+		throw Exception("Missing required arguments for struct_insert function.");
+	}
+
+	if (LogicalTypeId::STRUCT != arguments[0]->return_type.id()) {
+		throw Exception("The first argument to struct_insert must be a STRUCT");
+	}
+
+	if (arguments.size() < 2) {
+		throw Exception("Can't insert nothing into a struct");
+	}
+
+	child_list_t<LogicalType> new_struct_children;
+
+	auto &existing_struct_children = StructType::GetChildTypes(arguments[0]->return_type);
+
+	for (size_t i = 0; i < existing_struct_children.size(); i++) {
+		auto &child = existing_struct_children[i];
+		name_collision_set.insert(child.first);
+		new_struct_children.push_back(make_pair(child.first, child.second));
+	}
+
+	// Loop through the additional arguments (name/value pairs)
+	for (idx_t i = 1; i < arguments.size(); i++) {
+		auto &child = arguments[i];
+		if (child->alias.empty() && bound_function.name == "struct_insert") {
+			throw BinderException("Need named argument for struct insert, e.g. STRUCT_PACK(a := b)");
+		}
+		if (name_collision_set.find(child->alias) != name_collision_set.end()) {
+			throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
+		}
+		name_collision_set.insert(child->alias);
+		new_struct_children.push_back(make_pair(child->alias, arguments[i]->return_type));
+	}
+
+	// this is more for completeness reasons
+	bound_function.return_type = LogicalType::STRUCT(move(new_struct_children));
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
+
+	auto &existing_struct_stats = (StructStatistics &)*child_stats[0];
+	auto new_struct_stats = make_unique<StructStatistics>(expr.return_type);
+
+	for (idx_t i = 0; i < existing_struct_stats.child_stats.size(); i++) {
+		new_struct_stats->child_stats[i] =
+		    existing_struct_stats.child_stats[i] ? existing_struct_stats.child_stats[i]->Copy() : nullptr;
+	}
+
+	auto offset = new_struct_stats->child_stats.size() - child_stats.size();
+	for (idx_t i = 1; i < child_stats.size(); i++) {
+		new_struct_stats->child_stats[offset + i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
+	}
+	return move(new_struct_stats);
+}
+
+void StructInsertFun::RegisterFunction(BuiltinFunctions &set) {
+	// the arguments and return types are actually set in the binder function
+	ScalarFunction fun("struct_insert", {}, LogicalTypeId::STRUCT, StructInsertFunction, false, StructInsertBind,
+	                   nullptr, StructInsertStats);
+	fun.varargs = LogicalType::ANY;
+	set.AddFunction(fun);
+}
+
+} // namespace duckdb
+
+
+
+
+
+
+
+
 namespace duckdb {
 
 static void StructPackFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -105270,7 +105380,7 @@ typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(
     TableFilterSet *filters);
 typedef void (*stream_factory_get_schema_t)(uintptr_t stream_factory_ptr, ArrowSchemaWrapper &schema);
 
-struct ArrowScanFunctionData : public TableFunctionData {
+struct ArrowScanFunctionData : public PyTableFunctionData {
 	ArrowScanFunctionData(idx_t rows_per_thread_p, stream_factory_produce_t scanner_producer_p,
 	                      uintptr_t stream_factory_ptr_p)
 	    : lines_read(0), rows_per_thread(rows_per_thread_p), stream_factory_ptr(stream_factory_ptr_p),
@@ -169723,6 +169833,10 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
 		                                  table_function.function_info.get());
 		bind_data = table_function.bind(context, bind_input, return_types, return_names);
+		if (table_function.name == "pandas_scan" || table_function.name == "arrow_scan") {
+			auto arrow_bind = (PyTableFunctionData *)bind_data.get();
+			arrow_bind->external_dependency = move(ref.external_dependency);
+		}
 	}
 	if (return_types.size() != return_names.size()) {
 		throw InternalException(
@@ -173982,7 +174096,9 @@ void Planner::CreatePlan(SQLStatement &statement) {
 			value_map[expr->parameter_nr] = vector<unique_ptr<Value>>();
 		} else if (entry->second.back()->type() != value->type()) {
 			// used before, but types are inconsistent
-			throw BinderException("Inconsistent types found for parameter with index %llu", expr->parameter_nr);
+			throw BinderException(
+			    "Inconsistent types found for parameter with index %llu, current type %s, new type %s",
+			    expr->parameter_nr, entry->second.back()->type().ToString(), value->type().ToString());
 		}
 		value_map[expr->parameter_nr].push_back(move(value));
 	}

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "7548d73b3"
-#define DUCKDB_VERSION "v0.4.1-dev144"
+#define DUCKDB_SOURCE_ID "babe830d3"
+#define DUCKDB_VERSION "v0.4.1-dev160"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5453,7 +5453,6 @@ private:
 
 
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5659,6 +5658,29 @@ using named_parameter_map_t = case_insensitive_map_t<Value>;
 } // namespace duckdb
 
 
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/external_dependencies.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+namespace duckdb {
+
+enum ExternalDependenciesType { PYTHON_DEPENDENCY };
+class ExternalDependency {
+public:
+	explicit ExternalDependency(ExternalDependenciesType type_p) : type(type_p) {};
+	virtual ~ExternalDependency() {};
+	ExternalDependenciesType type;
+};
+
+} // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -6362,6 +6384,11 @@ struct TableFunctionData : public FunctionData {
 	DUCKDB_API bool Equals(const FunctionData &other) const override;
 };
 
+struct PyTableFunctionData : public TableFunctionData {
+	//! External dependencies of this table function
+	unique_ptr<ExternalDependency> external_dependency;
+};
+
 struct FunctionParameters {
 	vector<Value> values;
 	named_parameter_map_t named_parameters;
@@ -17701,27 +17728,6 @@ public:
 
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/external_dependencies.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-namespace duckdb {
-
-enum ExternalDependenciesType { PYTHON_DEPENDENCY };
-class ExternalDependency {
-public:
-	explicit ExternalDependency(ExternalDependenciesType type_p) : type(type_p) {};
-	virtual ~ExternalDependency() {};
-	ExternalDependenciesType type;
-};
-
-} // namespace duckdb
 
 
 namespace duckdb {
@@ -24562,6 +24568,7 @@ public:
 
 
 
+
 namespace duckdb {
 //! Represents a Table producing function
 class TableFunctionRef : public TableRef {
@@ -24574,6 +24581,9 @@ public:
 	// if the function takes a subquery as argument its in here
 	unique_ptr<SelectStatement> subquery;
 
+	// External dependencies of this table funcion
+	unique_ptr<ExternalDependency> external_dependency;
+
 public:
 	string ToString() const override;