duckdb 0.4.1-dev1556.0 → 0.4.1-dev1564.0

package/package.json

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

package/src/duckdb.cpp

@@ -98731,17 +98731,8 @@ void ArraySliceFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
-namespace duckdb {
-
-template <class T>
-static inline bool ValueEqualsOrNot(const T &left, const T &right) {
-	return left == right;
-}
 
-template <>
-inline bool ValueEqualsOrNot(const string_t &left, const string_t &right) {
-	return StringComparisonOperators::EqualsOrNot<false>(left, right);
-}
+namespace duckdb {
 
 struct ContainsFunctor {
 	static inline bool Initialize() {
@@ -98816,15 +98807,16 @@ static void TemplatedContainsOrPosition(DataChunk &args, ExpressionState &state,
 			}
 
 			if (!is_nested) {
-				if (ValueEqualsOrNot<CHILD_TYPE>(child_value[child_value_idx], values[value_index])) {
+				if (Equals::Operation(child_value[child_value_idx], values[value_index])) {
 					result_entries[i] = OP::UpdateResultEntries(child_idx);
 					break; // Found value in list, no need to look further
 				}
 			} else {
 				// FIXME: using Value is less efficient than modifying the vector comparison code
 				// to more efficiently compare nested types
-				if (ValueEqualsOrNot<Value>(child_vector.GetValue(child_value_idx),
-				                            value_vector.GetValue(value_index))) {
+				auto lvalue = child_vector.GetValue(child_value_idx);
+				auto rvalue = value_vector.GetValue(value_index);
+				if (Value::NotDistinctFrom(lvalue, rvalue)) {
 					result_entries[i] = OP::UpdateResultEntries(child_idx);
 					break; // Found value in list, no need to look further
 				}
@@ -99340,7 +99332,6 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 
 			// states vector is full, update
 			if (states_idx == STANDARD_VECTOR_SIZE) {
-
 				// update the aggregate state(s)
 				Vector slice = Vector(child_vector, sel_vector, states_idx);
 				aggr.function.update(&slice, aggr_input_data, 1, state_vector_update, states_idx);
@@ -99445,14 +99436,21 @@ static void ListUniqueFunction(DataChunk &args, ExpressionState &state, Vector &
 }
 
 template <bool IS_AGGR = false>
-static unique_ptr<FunctionData> ListAggregatesBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                           const LogicalType &list_child_type,
-                                                           AggregateFunction &aggr_function) {
+static unique_ptr<FunctionData>
+ListAggregatesBindFunction(ClientContext &context, ScalarFunction &bound_function, const LogicalType &list_child_type,
+                           AggregateFunction &aggr_function, vector<unique_ptr<Expression>> &arguments) {
 
 	// create the child expression and its type
 	vector<unique_ptr<Expression>> children;
 	auto expr = make_unique<BoundConstantExpression>(Value(list_child_type));
 	children.push_back(move(expr));
+	// push any extra arguments into the list aggregate bind
+	if (arguments.size() > 2) {
+		for (idx_t i = 2; i < arguments.size(); i++) {
+			children.push_back(move(arguments[i]));
+		}
+		arguments.resize(2);
+	}
 
 	auto bound_aggr_function = AggregateFunction::BindAggregateFunction(context, aggr_function, move(children));
 	bound_function.arguments[0] = LogicalType::LIST(bound_aggr_function->function.arguments[0]);
@@ -99460,6 +99458,12 @@ static unique_ptr<FunctionData> ListAggregatesBindFunction(ClientContext &contex
 	if (IS_AGGR) {
 		bound_function.return_type = bound_aggr_function->function.return_type;
 	}
+	// check if the aggregate function consumed all the extra input arguments
+	if (bound_aggr_function->children.size() > 1) {
+		throw InvalidInputException(
+		    "Aggregate function %s is not supported for list_aggr: extra arguments were not removed during bind",
+		    bound_aggr_function->ToString());
+	}
 
 	return make_unique<ListAggregatesBindData>(bound_function.return_type, move(bound_aggr_function));
 }
@@ -99478,7 +99482,6 @@ static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, Scala
 
 	string function_name = "histogram";
 	if (IS_AGGR) { // get the name of the aggregate function
-
 		if (!arguments[1]->IsFoldable()) {
 			throw InvalidInputException("Aggregate function name must be a constant");
 		}
@@ -99503,31 +99506,35 @@ static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, Scala
 	string error;
 	vector<LogicalType> types;
 	types.push_back(list_child_type);
+	// push any extra arguments into the type list
+	for (idx_t i = 2; i < arguments.size(); i++) {
+		types.push_back(arguments[i]->return_type);
+	}
 	auto best_function_idx = Function::BindFunction(func->name, func->functions, types, error);
 	if (best_function_idx == DConstants::INVALID_INDEX) {
-		throw BinderException("No matching aggregate function");
+		throw BinderException("No matching aggregate function\n%s", error);
 	}
 
 	// found a matching function, bind it as an aggregate
 	auto &best_function = func->functions[best_function_idx];
 
 	if (IS_AGGR) {
-		return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, list_child_type, best_function);
+		return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, list_child_type, best_function, arguments);
 	}
 
 	// create the unordered map histogram function
 	D_ASSERT(best_function.arguments.size() == 1);
 	auto key_type = best_function.arguments[0];
 	auto aggr_function = HistogramFun::GetHistogramUnorderedMap(key_type);
-	return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, list_child_type, aggr_function);
+	return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, list_child_type, aggr_function, arguments);
 }
 
 static unique_ptr<FunctionData> ListAggregateBind(ClientContext &context, ScalarFunction &bound_function,
                                                   vector<unique_ptr<Expression>> &arguments) {
 
 	// the list column and the name of the aggregate function
-	D_ASSERT(bound_function.arguments.size() == 2);
-	D_ASSERT(arguments.size() == 2);
+	D_ASSERT(bound_function.arguments.size() >= 2);
+	D_ASSERT(arguments.size() >= 2);
 
 	return ListAggregatesBind<true>(context, bound_function, arguments);
 }
@@ -99556,6 +99563,7 @@ ScalarFunction ListAggregateFun::GetFunction() {
 	auto result = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY,
 	                             ListAggregateFunction, ListAggregateBind);
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	result.varargs = LogicalType::ANY;
 	return result;
 }
 
@@ -120338,6 +120346,7 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 
 
 
+
 namespace duckdb {
 
 struct CTableFunctionInfo : public TableFunctionInfo {
@@ -120369,6 +120378,7 @@ struct CTableBindData : public TableFunctionData {
 	CTableFunctionInfo *info = nullptr;
 	void *bind_data = nullptr;
 	duckdb_delete_callback_t delete_callback = nullptr;
+	unique_ptr<NodeStatistics> stats;
 };
 
 struct CTableInternalBindInfo {
@@ -120483,6 +120493,14 @@ unique_ptr<LocalTableFunctionState> CTableFunctionLocalInit(ExecutionContext &co
 	return move(result);
 }
 
+unique_ptr<NodeStatistics> CTableFunctionCardinality(ClientContext &context, const FunctionData *bind_data_p) {
+	auto &bind_data = (const CTableBindData &)*bind_data_p;
+	if (!bind_data.stats) {
+		return nullptr;
+	}
+	return make_unique<NodeStatistics>(*bind_data.stats);
+}
+
 void CTableFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (CTableBindData &)*data_p.bind_data;
 	auto &global_data = (CTableGlobalInitData &)*data_p.global_state;
@@ -120503,6 +120521,7 @@ duckdb_table_function duckdb_create_table_function() {
 	auto function = new duckdb::TableFunction("", {}, duckdb::CTableFunction, duckdb::CTableFunctionBind,
 	                                          duckdb::CTableFunctionInit, duckdb::CTableFunctionLocalInit);
 	function->function_info = duckdb::make_shared<duckdb::CTableFunctionInfo>();
+	function->cardinality = duckdb::CTableFunctionCardinality;
 	return function;
 }
 
@@ -120651,6 +120670,18 @@ void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_de
 	bind_info->bind_data.delete_callback = destroy;
 }
 
+void duckdb_bind_set_cardinality(duckdb_bind_info info, idx_t cardinality, bool is_exact) {
+	if (!info) {
+		return;
+	}
+	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
+	if (is_exact) {
+		bind_info->bind_data.stats = duckdb::make_unique<duckdb::NodeStatistics>(cardinality);
+	} else {
+		bind_info->bind_data.stats = duckdb::make_unique<duckdb::NodeStatistics>(cardinality, cardinality);
+	}
+}
+
 void duckdb_bind_set_error(duckdb_bind_info info, const char *error) {
 	if (!info || !error) {
 		return;

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 "540eab3cc"
-#define DUCKDB_VERSION "v0.4.1-dev1556"
+#define DUCKDB_SOURCE_ID "ebe45abbb"
+#define DUCKDB_VERSION "v0.4.1-dev1564"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -17860,6 +17860,14 @@ Sets the user-provided bind data in the bind object. This object can be retrieve
 */
 DUCKDB_API void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
 
+/*!
+Sets the cardinality estimate for the table function, used for optimization.
+
+* info: The bind data object.
+* is_exact: Whether or not the cardinality estimate is exact, or an approximation
+*/
+DUCKDB_API void duckdb_bind_set_cardinality(duckdb_bind_info info, idx_t cardinality, bool is_exact);
+
 /*!
 Report that an error has occurred while calling bind.