duckdb 0.7.2-dev1671.0 → 0.7.2-dev1684.0

package/package.json

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

package/src/duckdb/src/execution/expression_executor.cpp

@@ -56,7 +56,7 @@ Allocator &ExpressionExecutor::GetAllocator() {
 
 void ExpressionExecutor::AddExpression(const Expression &expr) {
 	expressions.push_back(&expr);
-	auto state = make_uniq<ExpressionExecutorState>(expr.ToString());
+	auto state = make_uniq<ExpressionExecutorState>();
 	Initialize(expr, *state);
 	state->Verify();
 	states.push_back(std::move(state));

package/src/duckdb/src/execution/expression_executor_state.cpp

@@ -31,11 +31,10 @@ ClientContext &ExpressionState::GetContext() {
 	return root.executor->GetContext();
 }
 
-ExpressionState::ExpressionState(const Expression &expr, ExpressionExecutorState &root)
-    : expr(expr), root(root), name(expr.ToString()) {
+ExpressionState::ExpressionState(const Expression &expr, ExpressionExecutorState &root) : expr(expr), root(root) {
 }
 
-ExpressionExecutorState::ExpressionExecutorState(const string &name) : profiler(), name(name) {
+ExpressionExecutorState::ExpressionExecutorState() : profiler() {
 }
 
 void ExpressionState::Verify(ExpressionExecutorState &root_executor) {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev1671"
+#define DUCKDB_VERSION "0.7.2-dev1684"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "846a32b4c8"
+#define DUCKDB_SOURCE_ID "754ff32005"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp

@@ -29,7 +29,6 @@ struct ExpressionState {
 	vector<unique_ptr<ExpressionState>> child_states;
 	vector<LogicalType> types;
 	DataChunk intermediate_chunk;
-	string name;
 	CycleCounter profiler;
 
 public:
@@ -55,12 +54,11 @@ public:
 };
 
 struct ExpressionExecutorState {
-	explicit ExpressionExecutorState(const string &name);
+	ExpressionExecutorState();
 
 	unique_ptr<ExpressionState> root_state;
 	ExpressionExecutor *executor = nullptr;
 	CycleCounter profiler;
-	string name;
 
 	void Verify();
 };

package/src/duckdb/src/include/duckdb/planner/pragma_handler.hpp

@@ -29,8 +29,9 @@ private:
 	ClientContext &context;
 
 private:
-	//! Handles a pragma statement, (potentially) returning a new statement to replace the current one
-	string HandlePragma(SQLStatement *statement);
+	//! Handles a pragma statement, returns whether the statement was expanded, if it was expanded the 'resulting_query'
+	//! contains the statement(s) to replace the current one
+	bool HandlePragma(SQLStatement *statement, string &resulting_query);
 
 	void HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatement>> &statements);
 };

package/src/duckdb/src/main/query_profiler.cpp

@@ -690,7 +690,7 @@ ExpressionExecutorInfo::ExpressionExecutorInfo(ExpressionExecutor &executor, con
 ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string name)
     : current_count(state.profiler.current_count), sample_count(state.profiler.sample_count),
       sample_tuples_count(state.profiler.sample_tuples_count), tuples_count(state.profiler.tuples_count),
-      name(state.name), time(state.profiler.time) {
+      name("expression"), time(state.profiler.time) {
 	// Use the name of expression-tree as extra-info
 	extra_info = std::move(name);
 	auto expression_info_p = make_uniq<ExpressionInfo>();

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

@@ -32,8 +32,9 @@ void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatemen
 		if (statements[i]->type == StatementType::PRAGMA_STATEMENT) {
 			// PRAGMA statement: check if we need to replace it by a new set of statements
 			PragmaHandler handler(context);
-			auto new_query = handler.HandlePragma(statements[i].get());
-			if (!new_query.empty()) {
+			string new_query;
+			bool expanded = handler.HandlePragma(statements[i].get(), new_query);
+			if (expanded) {
 				// this PRAGMA statement gets replaced by a new query string
 				// push the new query string through the parser again and add it to the transformer
 				Parser parser(context.GetParserOptions());
@@ -67,7 +68,7 @@ void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<uniqu
 	context.RunFunctionInTransactionInternal(lock, [&]() { HandlePragmaStatementsInternal(statements); });
 }
 
-string PragmaHandler::HandlePragma(SQLStatement *statement) { // PragmaInfo &info
+bool PragmaHandler::HandlePragma(SQLStatement *statement, string &resulting_query) { // PragmaInfo &info
 	auto info = *(statement->Cast<PragmaStatement>()).info;
 	auto entry =
 	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name, false);
@@ -84,9 +85,10 @@ string PragmaHandler::HandlePragma(SQLStatement *statement) { // PragmaInfo &inf
 		Binder::BindNamedParameters(bound_function.named_parameters, info.named_parameters, error_context,
 		                            bound_function.name);
 		FunctionParameters parameters {info.parameters, info.named_parameters};
-		return bound_function.query(context, parameters);
+		resulting_query = bound_function.query(context, parameters);
+		return true;
 	}
-	return string();
+	return false;
 }
 
 } // namespace duckdb