duckdb 0.3.3-dev164.0 → 0.3.3-dev224.0

package/package.json

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

package/src/duckdb.cpp

@@ -101843,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
@@ -101862,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);
 	}
@@ -101913,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)
@@ -110944,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;
@@ -111236,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;
@@ -111548,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;
@@ -111808,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;
@@ -111903,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;
@@ -111989,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;
@@ -112072,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 "53df4da5f"
-#define DUCKDB_VERSION "v0.3.3-dev164"
+#define DUCKDB_SOURCE_ID "99421af3f"
+#define DUCKDB_VERSION "v0.3.3-dev224"
 //===----------------------------------------------------------------------===//
 //                         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;