duckdb 0.3.3-dev151.0 → 0.3.3-dev192.0

package/package.json

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

package/src/duckdb.cpp

@@ -81174,59 +81174,48 @@ void ListExtractTemplate(idx_t count, VectorData &list_data, VectorData &offsets
 static void ExecuteListExtractInternal(const idx_t count, VectorData &list, VectorData &offsets, Vector &child_vector,
                                        idx_t list_size, Vector &result) {
 	D_ASSERT(child_vector.GetType() == result.GetType());
-	switch (result.GetType().id()) {
-	case LogicalTypeId::UTINYINT:
-		ListExtractTemplate<uint8_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case LogicalTypeId::TINYINT:
+	switch (result.GetType().InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
 		ListExtractTemplate<int8_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::USMALLINT:
-		ListExtractTemplate<uint16_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case LogicalTypeId::SMALLINT:
+	case PhysicalType::INT16:
 		ListExtractTemplate<int16_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::UINTEGER:
-		ListExtractTemplate<uint32_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case LogicalTypeId::INTEGER:
+	case PhysicalType::INT32:
 		ListExtractTemplate<int32_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::UBIGINT:
-		ListExtractTemplate<uint64_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case LogicalTypeId::BIGINT:
+	case PhysicalType::INT64:
 		ListExtractTemplate<int64_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::HUGEINT:
+	case PhysicalType::INT128:
 		ListExtractTemplate<hugeint_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::FLOAT:
-		ListExtractTemplate<float>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::UINT8:
+		ListExtractTemplate<uint8_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::DOUBLE:
-		ListExtractTemplate<double>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::UINT16:
+		ListExtractTemplate<uint16_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::DATE:
-		ListExtractTemplate<date_t>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::UINT32:
+		ListExtractTemplate<uint32_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		ListExtractTemplate<dtime_t>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::UINT64:
+		ListExtractTemplate<uint64_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		ListExtractTemplate<timestamp_t>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::FLOAT:
+		ListExtractTemplate<float>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::VARCHAR:
+	case PhysicalType::DOUBLE:
+		ListExtractTemplate<double>(count, list, offsets, child_vector, list_size, result);
+		break;
+	case PhysicalType::VARCHAR:
 		ListExtractTemplate<string_t, true>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::SQLNULL:
-		result.Reference(Value());
+	case PhysicalType::INTERVAL:
+		ListExtractTemplate<interval_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::STRUCT: {
+	case PhysicalType::STRUCT: {
 		auto &entries = StructVector::GetEntries(child_vector);
 		auto &result_entries = StructVector::GetEntries(result);
 		D_ASSERT(entries.size() == result_entries.size());
@@ -81238,7 +81227,7 @@ static void ExecuteListExtractInternal(const idx_t count, VectorData &list, Vect
 		ListExtractTemplate<bool, false, true>(count, list, offsets, child_vector, list_size, result);
 		break;
 	}
-	case LogicalTypeId::LIST: {
+	case PhysicalType::LIST: {
 		// nested list: we have to reference the child
 		auto &child_child_list = ListVector::GetEntry(child_vector);
 
@@ -101854,6 +101843,10 @@ void DuckDB::SetExtensionLoaded(const std::string &name) {
 #include "tpcds-extension.hpp"
 #endif
 
+#if defined(BUILD_SUBSTRAIT_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#include "substrait-extension.hpp"
+#endif
+
 #if defined(BUILD_FTS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "fts-extension.hpp"
 #endif
@@ -101873,7 +101866,8 @@ void DuckDB::SetExtensionLoaded(const std::string &name) {
 namespace duckdb {
 
 void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
-	unordered_set<string> extensions {"parquet", "icu", "tpch", "tpcds", "fts", "httpfs", "visualizer", "excel"};
+	unordered_set<string> extensions {"parquet", "icu",       "tpch",       "tpcds", "fts",
+	                                  "httpfs",  "substrait", "visualizer", "excel"};
 	for (auto &ext : extensions) {
 		LoadExtensionInternal(db, ext, true);
 	}
@@ -101924,6 +101918,14 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 #else
 		// icu extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
+#endif
+	} else if (extension == "substrait") {
+#if defined(BUILD_SUBSTRAIT_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+
+		db.LoadExtension<SubstraitExtension>();
+#else
+		// substrait extension required but not build: skip this test
+		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "tpcds") {
 #if defined(BUILD_TPCDS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
@@ -110955,9 +110957,9 @@ namespace duckdb {
 
 class AggregateRelation : public Relation {
 public:
-	AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions);
-	AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
-	                  vector<unique_ptr<ParsedExpression>> groups);
+	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions);
+	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
+	                             vector<unique_ptr<ParsedExpression>> groups);
 
 	vector<unique_ptr<ParsedExpression>> expressions;
 	vector<unique_ptr<ParsedExpression>> groups;
@@ -111247,7 +111249,7 @@ namespace duckdb {
 
 class CrossProductRelation : public Relation {
 public:
-	CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right);
+	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
@@ -111559,7 +111561,7 @@ namespace duckdb {
 
 class FilterRelation : public Relation {
 public:
-	FilterRelation(shared_ptr<Relation> child, unique_ptr<ParsedExpression> condition);
+	DUCKDB_API FilterRelation(shared_ptr<Relation> child, unique_ptr<ParsedExpression> condition);
 
 	unique_ptr<ParsedExpression> condition;
 	shared_ptr<Relation> child;
@@ -111819,9 +111821,10 @@ namespace duckdb {
 
 class JoinRelation : public Relation {
 public:
-	JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, unique_ptr<ParsedExpression> condition,
-	             JoinType type);
-	JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, vector<string> using_columns, JoinType type);
+	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
+	                        unique_ptr<ParsedExpression> condition, JoinType type);
+	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, vector<string> using_columns,
+	                        JoinType type);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
@@ -111914,7 +111917,7 @@ namespace duckdb {
 
 class LimitRelation : public Relation {
 public:
-	LimitRelation(shared_ptr<Relation> child, int64_t limit, int64_t offset);
+	DUCKDB_API LimitRelation(shared_ptr<Relation> child, int64_t limit, int64_t offset);
 
 	int64_t limit;
 	int64_t offset;
@@ -112000,7 +112003,7 @@ namespace duckdb {
 
 class OrderRelation : public Relation {
 public:
-	OrderRelation(shared_ptr<Relation> child, vector<OrderByNode> orders);
+	DUCKDB_API OrderRelation(shared_ptr<Relation> child, vector<OrderByNode> orders);
 
 	vector<OrderByNode> orders;
 	shared_ptr<Relation> child;
@@ -112083,8 +112086,8 @@ namespace duckdb {
 
 class ProjectionRelation : public Relation {
 public:
-	ProjectionRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
-	                   vector<string> aliases);
+	DUCKDB_API ProjectionRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
+	                              vector<string> aliases);
 
 	vector<unique_ptr<ParsedExpression>> expressions;
 	vector<ColumnDefinition> columns;

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 "feaf379f9"
-#define DUCKDB_VERSION "v0.3.3-dev151"
+#define DUCKDB_SOURCE_ID "0b9c1c20e"
+#define DUCKDB_VERSION "v0.3.3-dev192"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -729,7 +729,7 @@ public:
 	hugeint_t &operator=(const hugeint_t &rhs) = default;
 	hugeint_t &operator=(hugeint_t &&rhs) = default;
 
-	string ToString() const;
+	DUCKDB_API string ToString() const;
 
 	// comparison operators
 	bool operator==(const hugeint_t &rhs) const;
@@ -5909,7 +5909,7 @@ enum class ExpressionClass : uint8_t {
 	BOUND_EXPRESSION = 50
 };
 
-string ExpressionTypeToString(ExpressionType type);
+DUCKDB_API string ExpressionTypeToString(ExpressionType type);
 string ExpressionTypeToOperator(ExpressionType type);
 
 //! Negate a comparison expression, turning e.g. = into !=, or < into >=
@@ -8239,7 +8239,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_LOAD = 180
 };
 
-string LogicalOperatorToString(LogicalOperatorType type);
+DUCKDB_API string LogicalOperatorToString(LogicalOperatorType type);
 
 } // namespace duckdb
 
@@ -10745,7 +10745,7 @@ enum class JoinType : uint8_t {
 };
 
 //! Convert join type to string
-string JoinTypeToString(JoinType type);
+DUCKDB_API string JoinTypeToString(JoinType type);
 
 //! True if join is left or full outer join
 bool IsLeftOuterJoin(JoinType type);
@@ -20045,8 +20045,8 @@ public:
 	static vector<ParserKeyword> KeywordList();
 
 	//! Parses a list of expressions (i.e. the list found in a SELECT clause)
-	static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list,
-	                                                                ParserOptions options = ParserOptions());
+	DUCKDB_API static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list,
+	                                                                           ParserOptions options = ParserOptions());
 	//! Parses a list as found in an ORDER BY expression (i.e. including optional ASCENDING/DESCENDING modifiers)
 	static vector<OrderByNode> ParseOrderList(const string &select_list, ParserOptions options = ParserOptions());
 	//! Parses an update list (i.e. the list found in the SET clause of an UPDATE statement)
@@ -21106,7 +21106,7 @@ struct CaseCheck {
 //! The CaseExpression represents a CASE expression in the query
 class CaseExpression : public ParsedExpression {
 public:
-	CaseExpression();
+	DUCKDB_API CaseExpression();
 
 	vector<CaseCheck> case_checks;
 	unique_ptr<ParsedExpression> else_expr;
@@ -21140,9 +21140,10 @@ namespace duckdb {
 //! Represents a conjunction (AND/OR)
 class ConjunctionExpression : public ParsedExpression {
 public:
-	explicit ConjunctionExpression(ExpressionType type);
-	ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-	ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
+	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
+	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
+	                                 unique_ptr<ParsedExpression> right);
 
 	vector<unique_ptr<ParsedExpression>> children;
 
@@ -21177,12 +21178,15 @@ namespace duckdb {
 //! Represents a function call
 class FunctionExpression : public ParsedExpression {
 public:
-	FunctionExpression(string schema_name, const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
-	                   bool distinct = false, bool is_operator = false, bool export_state = false);
-	FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
-	                   bool distinct = false, bool is_operator = false, bool export_state = false);
+	DUCKDB_API FunctionExpression(string schema_name, const string &function_name,
+	                              vector<unique_ptr<ParsedExpression>> children,
+	                              unique_ptr<ParsedExpression> filter = nullptr,
+	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
+	                              bool is_operator = false, bool export_state = false);
+	DUCKDB_API FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
+	                              unique_ptr<ParsedExpression> filter = nullptr,
+	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
+	                              bool is_operator = false, bool export_state = false);
 
 	//! Schema of the function
 	string schema;
@@ -21261,7 +21265,8 @@ namespace duckdb {
 //! and has two children.
 class ComparisonExpression : public ParsedExpression {
 public:
-	ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
+	DUCKDB_API ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
+	                                unique_ptr<ParsedExpression> right);
 
 	unique_ptr<ParsedExpression> left;
 	unique_ptr<ParsedExpression> right;
@@ -21295,7 +21300,7 @@ namespace duckdb {
 //! ConstantExpression represents a constant value in the query
 class ConstantExpression : public ParsedExpression {
 public:
-	explicit ConstantExpression(Value val);
+	DUCKDB_API explicit ConstantExpression(Value val);
 
 	//! The constant value referenced
 	Value value;
@@ -21330,9 +21335,9 @@ namespace duckdb {
 //! Represents a built-in operator expression
 class OperatorExpression : public ParsedExpression {
 public:
-	explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
-	                            unique_ptr<ParsedExpression> right = nullptr);
-	OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	DUCKDB_API explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
+	                                       unique_ptr<ParsedExpression> right = nullptr);
+	DUCKDB_API OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
 
 	vector<unique_ptr<ParsedExpression>> children;
 
@@ -21396,7 +21401,7 @@ public:
 namespace duckdb {
 class PositionalReferenceExpression : public ParsedExpression {
 public:
-	PositionalReferenceExpression(idx_t index);
+	DUCKDB_API PositionalReferenceExpression(idx_t index);
 
 	idx_t index;
 
@@ -21436,7 +21441,7 @@ namespace duckdb {
 //! CastExpression represents a type cast from one SQL type to another SQL type
 class CastExpression : public ParsedExpression {
 public:
-	CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
+	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
 
 	//! The child of the cast expression
 	unique_ptr<ParsedExpression> child;