duckdb 0.6.2-dev1241.0 → 0.6.2-dev1247.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev1241.0",
+  "version": "0.6.2-dev1247.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev1241"
+#define DUCKDB_VERSION "0.6.2-dev1247"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "7fb3c46a62"
+#define DUCKDB_SOURCE_ID "5fb349c5ab"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp

@@ -8,8 +8,9 @@
 
 #pragma once
 
-#include "duckdb/parser/parsed_data/parse_info.hpp"
 #include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/parser/parsed_data/parse_info.hpp"
 
 namespace duckdb {
 
@@ -45,6 +46,32 @@ public:
 		result->allow_drop_internal = allow_drop_internal;
 		return result;
 	}
+
+	void Serialize(Serializer &serializer) const {
+		FieldWriter writer(serializer);
+		writer.WriteField<CatalogType>(type);
+		writer.WriteString(catalog);
+		writer.WriteString(schema);
+		writer.WriteString(name);
+		writer.WriteField(if_exists);
+		writer.WriteField(cascade);
+		writer.WriteField(allow_drop_internal);
+		writer.Finalize();
+	}
+
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer) {
+		FieldReader reader(deserializer);
+		auto drop_info = make_unique<DropInfo>();
+		drop_info->type = reader.ReadRequired<CatalogType>();
+		drop_info->catalog = reader.ReadRequired<string>();
+		drop_info->schema = reader.ReadRequired<string>();
+		drop_info->name = reader.ReadRequired<string>();
+		drop_info->if_exists = reader.ReadRequired<bool>();
+		drop_info->cascade = reader.ReadRequired<bool>();
+		drop_info->allow_drop_internal = reader.ReadRequired<bool>();
+		reader.Finalize();
+		return std::move(drop_info);
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/load_info.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/parsed_data/parse_info.hpp"
 
 namespace duckdb {
@@ -25,6 +26,22 @@ public:
 		result->load_type = load_type;
 		return result;
 	}
+
+	void Serialize(Serializer &serializer) const {
+		FieldWriter writer(serializer);
+		writer.WriteString(filename);
+		writer.WriteField<LoadType>(load_type);
+		writer.Finalize();
+	}
+
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer) {
+		FieldReader reader(deserializer);
+		auto load_info = make_unique<LoadInfo>();
+		load_info->filename = reader.ReadRequired<string>();
+		load_info->load_type = reader.ReadRequired<LoadType>();
+		reader.Finalize();
+		return std::move(load_info);
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp

@@ -1,16 +1,16 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/function/function_binder.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/expression/lambda_expression.hpp"
+#include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/expression/lambda_expression.hpp"
-#include "duckdb/function/function_binder.hpp"
 
 namespace duckdb {
 
@@ -28,6 +28,13 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 	auto func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
 	                              function.function_name, false, error_context);
 
+	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY &&
+	    (function.distinct || function.filter || !function.order_bys->orders.empty())) {
+		throw InvalidInputException("Function \"%s\" is a %s. \"DISTINCT\", \"FILTER\", and \"ORDER BY\" are only "
+		                            "applicable to aggregate functions.",
+		                            function.function_name, CatalogTypeToString(func->type));
+	}
+
 	switch (func->type) {
 	case CatalogType::SCALAR_FUNCTION_ENTRY:
 		// scalar function

package/src/duckdb/src/planner/operator/logical_simple.cpp

@@ -1,13 +1,44 @@
 #include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/parser/parsed_data/alter_info.hpp"
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+#include "duckdb/parser/parsed_data/load_info.hpp"
 
 namespace duckdb {
 
 void LogicalSimple::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(LogicalOperatorToString(type));
+	writer.WriteField<LogicalOperatorType>(type);
+	switch (type) {
+	case LogicalOperatorType::LOGICAL_ALTER:
+		static_cast<const AlterInfo &>(*info).Serialize(writer.GetSerializer());
+		break;
+	case LogicalOperatorType::LOGICAL_DROP:
+		static_cast<const DropInfo &>(*info).Serialize(writer.GetSerializer());
+		break;
+	case LogicalOperatorType::LOGICAL_LOAD:
+		static_cast<const LoadInfo &>(*info).Serialize(writer.GetSerializer());
+		break;
+	default:
+		throw NotImplementedException(LogicalOperatorToString(type));
+	}
 }
 
 unique_ptr<LogicalOperator> LogicalSimple::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException(LogicalOperatorToString(state.type));
+	auto type = reader.ReadRequired<LogicalOperatorType>();
+	unique_ptr<ParseInfo> parse_info;
+	switch (type) {
+	case LogicalOperatorType::LOGICAL_ALTER:
+		parse_info = AlterInfo::Deserialize(reader.GetSource());
+		break;
+	case LogicalOperatorType::LOGICAL_DROP:
+		parse_info = DropInfo::Deserialize(reader.GetSource());
+		break;
+	case LogicalOperatorType::LOGICAL_LOAD:
+		parse_info = LoadInfo::Deserialize(reader.GetSource());
+		break;
+	default:
+		throw NotImplementedException(LogicalOperatorToString(state.type));
+	}
+	return make_unique<LogicalSimple>(type, std::move(parse_info));
 }
 
 idx_t LogicalSimple::EstimateCardinality(ClientContext &context) {

package/src/duckdb/src/planner/planner.cpp

@@ -154,13 +154,11 @@ static bool OperatorSupportsSerialization(LogicalOperator &op) {
 	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
 	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-	case LogicalOperatorType::LOGICAL_DROP:
 	case LogicalOperatorType::LOGICAL_PRAGMA:
 	case LogicalOperatorType::LOGICAL_TRANSACTION:
 	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
 	case LogicalOperatorType::LOGICAL_EXPLAIN:
 	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-	case LogicalOperatorType::LOGICAL_LOAD:
 	case LogicalOperatorType::LOGICAL_VACUUM:
 		// unsupported (for now)
 		return false;