duckdb 0.4.1-dev204.0 → 0.4.1-dev218.0

package/package.json

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

package/src/duckdb.cpp

@@ -227,6 +227,10 @@ public:
 public:
 	//! Serialize the meta information
 	virtual void Serialize(Serializer &serializer) = 0;
+
+	string ToSQL() override {
+		return function->ToSQL(schema->name, name);
+	}
 };
 
 } // namespace duckdb
@@ -1643,6 +1647,8 @@ public:
 
 public:
 	unique_ptr<MacroFunction> Copy() override;
+
+	string ToSQL(const string &schema, const string &name) override;
 };
 
 } // namespace duckdb
@@ -1656,7 +1662,7 @@ public:
 //===----------------------------------------------------------------------===//
 
 
-//! The SelectStatement of the view
+
 
 
 
@@ -1677,6 +1683,8 @@ public:
 
 public:
 	unique_ptr<MacroFunction> Copy() override;
+
+	string ToSQL(const string &schema, const string &name) override;
 };
 
 } // namespace duckdb
@@ -71883,6 +71891,7 @@ public:
 
 
 
+
 #include <algorithm>
 #include <sstream>
 
@@ -71987,6 +71996,7 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	vector<CatalogEntry *> tables;
 	vector<CatalogEntry *> views;
 	vector<CatalogEntry *> indexes;
+	vector<CatalogEntry *> macros;
 
 	auto schema_list = Catalog::GetCatalog(ccontext).schemas->GetEntries<SchemaCatalogEntry>(context.client);
 	for (auto &schema : schema_list) {
@@ -72006,6 +72016,16 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 		schema->Scan(context.client, CatalogType::TYPE_ENTRY,
 		             [&](CatalogEntry *entry) { custom_types.push_back(entry); });
 		schema->Scan(context.client, CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) { indexes.push_back(entry); });
+		schema->Scan(context.client, CatalogType::MACRO_ENTRY, [&](CatalogEntry *entry) {
+			if (!entry->internal && entry->type == CatalogType::MACRO_ENTRY) {
+				macros.push_back(entry);
+			}
+		});
+		schema->Scan(context.client, CatalogType::TABLE_MACRO_ENTRY, [&](CatalogEntry *entry) {
+			if (!entry->internal && entry->type == CatalogType::TABLE_MACRO_ENTRY) {
+				macros.push_back(entry);
+			}
+		});
 	}
 
 	// consider the order of tables because of foreign key constraint
@@ -72013,6 +72033,10 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 		tables.push_back((CatalogEntry *)exported_tables.data[i].entry);
 	}
 
+	// order macro's by timestamp so nested macro's are imported nicely
+	sort(macros.begin(), macros.end(),
+	     [](const CatalogEntry *lhs, const CatalogEntry *rhs) { return lhs->oid < rhs->oid; });
+
 	// write the schema.sql file
 	// export order is SCHEMA -> SEQUENCE -> TABLE -> VIEW -> INDEX
 
@@ -72023,6 +72047,7 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	WriteCatalogEntries(ss, tables);
 	WriteCatalogEntries(ss, views);
 	WriteCatalogEntries(ss, indexes);
+	WriteCatalogEntries(ss, macros);
 
 	WriteStringStreamToFile(fs, opener, ss, fs.JoinPath(info->file_path, "schema.sql"));
 
@@ -88680,6 +88705,18 @@ void MacroFunction::CopyProperties(MacroFunction &other) {
 	}
 }
 
+string MacroFunction::ToSQL(const string &schema, const string &name) {
+	vector<string> param_strings;
+	for (auto &param : parameters) {
+		param_strings.push_back(param->ToString());
+	}
+	for (auto &named_param : default_parameters) {
+		param_strings.push_back(StringUtil::Format("%s := %s", named_param.first, named_param.second->ToString()));
+	}
+
+	return StringUtil::Format("CREATE MACRO %s.%s(%s) AS ", schema, name, StringUtil::Join(param_strings, ", "));
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -105290,6 +105327,8 @@ void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vecto
 
 
 
+
+
 namespace duckdb {
 
 ScalarMacroFunction::ScalarMacroFunction(unique_ptr<ParsedExpression> expression)
@@ -105307,6 +105346,26 @@ unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
 	return move(result);
 }
 
+void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
+	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
+		auto &col_ref = (ColumnRefExpression &)*expr;
+		auto &col_names = col_ref.column_names;
+		if (col_names.size() == 2 && col_names[0] == MacroBinding::MACRO_NAME) {
+			col_names.erase(col_names.begin());
+		}
+	} else {
+		ParsedExpressionIterator::EnumerateChildren(
+		    *expr, [](unique_ptr<ParsedExpression> &child) { RemoveQualificationRecursive(child); });
+	}
+}
+
+string ScalarMacroFunction::ToSQL(const string &schema, const string &name) {
+	// In case of nested macro's we need to fix it a bit
+	auto expression_copy = expression->Copy();
+	RemoveQualificationRecursive(expression_copy);
+	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("(%s);", expression_copy->ToString());
+}
+
 } // namespace duckdb
 
 
@@ -112276,6 +112335,7 @@ TableFunction::TableFunction()
 
 
 
+
 namespace duckdb {
 
 TableMacroFunction::TableMacroFunction(unique_ptr<QueryNode> query_node)
@@ -112292,6 +112352,10 @@ unique_ptr<MacroFunction> TableMacroFunction::Copy() {
 	return move(result);
 }
 
+string TableMacroFunction::ToSQL(const string &schema, const string &name) {
+	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("TABLE (%s);", query_node->ToString());
+}
+
 } // namespace duckdb
 
 
@@ -126850,23 +126914,23 @@ namespace duckdb {
 
 #ifdef _WIN32
 
-void *dlopen(const char *file, int mode) {
+inline void *dlopen(const char *file, int mode) {
 	D_ASSERT(file);
 	return (void *)LoadLibrary(file);
 }
 
-void *dlsym(void *handle, const char *name) {
+inline void *dlsym(void *handle, const char *name) {
 	D_ASSERT(handle);
 	return (void *)GetProcAddress((HINSTANCE)handle, name);
 }
 
-std::string GetDLError(void) {
+inline std::string GetDLError(void) {
 	return LocalFileSystem::GetLastErrorAsString();
 }
 
 #else
 
-std::string GetDLError(void) {
+inline std::string GetDLError(void) {
 	return dlerror();
 }
 

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 "78baad646"
-#define DUCKDB_VERSION "v0.4.1-dev204"
+#define DUCKDB_SOURCE_ID "038c583ba"
+#define DUCKDB_VERSION "v0.4.1-dev218"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -24301,7 +24301,7 @@ struct BoundExportData : public ParseInfo {
 //===----------------------------------------------------------------------===//
 
 
-//! The SelectStatement of the view
+
 
 
 
@@ -24315,11 +24315,9 @@ enum class MacroType : uint8_t { VOID_MACRO = 0, TABLE_MACRO = 1, SCALAR_MACRO =
 
 class MacroFunction {
 public:
-	// explicit MacroFunction(unique_ptr<ParsedExpression> expression);
 	MacroFunction(MacroType type);
 
-	// MacroFunction(void);
-	// The type
+	//! The type
 	MacroType type;
 	//! The positional parameters
 	vector<unique_ptr<ParsedExpression>> parameters;
@@ -24338,6 +24336,8 @@ public:
 	                                FunctionExpression &function_expr,
 	                                vector<unique_ptr<ParsedExpression>> &positionals,
 	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
+
+	virtual string ToSQL(const string &schema, const string &name);
 };
 
 } // namespace duckdb