duckdb 0.8.2-dev2278.0 → 0.8.2-dev2320.0

package/binding.gyp

@@ -93,6 +93,7 @@
                 "src/duckdb/ub_src_main.cpp", 
                 "src/duckdb/ub_src_main_capi.cpp", 
                 "src/duckdb/ub_src_main_capi_cast.cpp", 
+                "src/duckdb/ub_src_main_chunk_scan_state.cpp", 
                 "src/duckdb/ub_src_main_extension.cpp", 
                 "src/duckdb/ub_src_main_relation.cpp", 
                 "src/duckdb/ub_src_main_settings.cpp", 

package/package.json

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

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/common/arrow/result_arrow_wrapper.hpp"
 #include "duckdb/common/arrow/arrow_appender.hpp"
 #include "duckdb/main/query_result.hpp"
+#include "duckdb/main/chunk_scan_state/query_result.hpp"
 
 namespace duckdb {
 
@@ -99,6 +100,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 	}
 	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 	auto &result = *my_stream->result;
+	auto &scan_state = *my_stream->scan_state;
 	if (result.HasError()) {
 		my_stream->last_error = result.GetErrorObject();
 		return -1;
@@ -117,7 +119,8 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 	}
 	idx_t result_count;
 	PreservedError error;
-	if (!ArrowUtil::TryFetchChunk(&result, my_stream->batch_size, out, result_count, error)) {
+	if (!ArrowUtil::TryFetchChunk(scan_state, result.GetArrowOptions(result), my_stream->batch_size, out, result_count,
+	                              error)) {
 		D_ASSERT(error);
 		my_stream->last_error = error;
 		return -1;
@@ -147,7 +150,7 @@ const char *ResultArrowArrayStreamWrapper::MyStreamGetLastError(struct ArrowArra
 }
 
 ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result_p, idx_t batch_size_p)
-    : result(std::move(result_p)) {
+    : result(std::move(result_p)), scan_state(make_uniq<QueryResultChunkScanState>(*result)) {
 	//! We first initialize the private data of the stream
 	stream.private_data = this;
 	//! Ceil Approx_Batch_Size/STANDARD_VECTOR_SIZE
@@ -162,52 +165,43 @@ ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryRes
 	stream.get_last_error = ResultArrowArrayStreamWrapper::MyStreamGetLastError;
 }
 
-bool ArrowUtil::TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &chunk, PreservedError &error) {
-	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = result.Cast<StreamQueryResult>();
-		if (!stream_result.IsOpen()) {
-			return true;
-		}
-	}
-	return result.TryFetch(chunk, error);
-}
-
-bool ArrowUtil::TryFetchChunk(QueryResult *result, idx_t chunk_size, ArrowArray *out, idx_t &count,
-                              PreservedError &error) {
+bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ArrowOptions options, idx_t batch_size, ArrowArray *out,
+                              idx_t &count, PreservedError &error) {
 	count = 0;
-	ArrowAppender appender(result->types, chunk_size, QueryResult::GetArrowOptions(*result));
-	auto &current_chunk = result->current_chunk;
-	if (current_chunk.Valid()) {
+	ArrowAppender appender(scan_state.Types(), batch_size, std::move(options));
+	auto remaining_tuples_in_chunk = scan_state.RemainingInChunk();
+	if (remaining_tuples_in_chunk) {
 		// We start by scanning the non-finished current chunk
-		// Limit the amount we're fetching to the chunk_size
-		idx_t cur_consumption = MinValue<idx_t>(current_chunk.RemainingSize(), chunk_size);
+		idx_t cur_consumption = MinValue(remaining_tuples_in_chunk, batch_size);
 		count += cur_consumption;
-		appender.Append(*current_chunk.data_chunk, current_chunk.position, current_chunk.position + cur_consumption,
-		                current_chunk.data_chunk->size());
-		current_chunk.position += cur_consumption;
-	}
-	while (count < chunk_size) {
-		unique_ptr<DataChunk> data_chunk;
-		if (!TryFetchNext(*result, data_chunk, error)) {
-			if (result->HasError()) {
-				error = result->GetErrorObject();
+		auto &current_chunk = scan_state.CurrentChunk();
+		appender.Append(current_chunk, scan_state.CurrentOffset(), scan_state.CurrentOffset() + cur_consumption,
+		                current_chunk.size());
+		scan_state.IncreaseOffset(cur_consumption);
+	}
+	while (count < batch_size) {
+		if (!scan_state.LoadNextChunk(error)) {
+			if (scan_state.HasError()) {
+				error = scan_state.GetError();
 			}
 			return false;
 		}
-		if (!data_chunk || data_chunk->size() == 0) {
+		if (scan_state.ChunkIsEmpty()) {
+			// The scan was successful, but an empty chunk was returned
 			break;
 		}
-		if (count + data_chunk->size() > chunk_size) {
-			// We have to split the chunk between this and the next batch
-			idx_t available_space = chunk_size - count;
-			appender.Append(*data_chunk, 0, available_space, data_chunk->size());
-			count += available_space;
-			current_chunk.data_chunk = std::move(data_chunk);
-			current_chunk.position = available_space;
-		} else {
-			count += data_chunk->size();
-			appender.Append(*data_chunk, 0, data_chunk->size(), data_chunk->size());
+		auto &current_chunk = scan_state.CurrentChunk();
+		if (scan_state.Finished() || current_chunk.size() == 0) {
+			break;
 		}
+		// The amount we still need to append into this chunk
+		auto remaining = batch_size - count;
+
+		// The amount remaining, capped by the amount left in the current chunk
+		auto to_append_to_batch = MinValue(remaining, scan_state.RemainingInChunk());
+		appender.Append(current_chunk, 0, to_append_to_batch, current_chunk.size());
+		count += to_append_to_batch;
+		scan_state.IncreaseOffset(to_append_to_batch);
 	}
 	if (count > 0) {
 		*out = appender.Finalize();
@@ -215,10 +209,10 @@ bool ArrowUtil::TryFetchChunk(QueryResult *result, idx_t chunk_size, ArrowArray
 	return true;
 }
 
-idx_t ArrowUtil::FetchChunk(QueryResult *result, idx_t chunk_size, ArrowArray *out) {
+idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ArrowOptions options, idx_t chunk_size, ArrowArray *out) {
 	PreservedError error;
 	idx_t result_count;
-	if (!TryFetchChunk(result, chunk_size, out, result_count, error)) {
+	if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error)) {
 		error.Throw();
 	}
 	return result_count;

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2278"
+#define DUCKDB_VERSION "0.8.2-dev2320"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "a868375e85"
+#define DUCKDB_SOURCE_ID "02412e1015"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/arrow/arrow_wrapper.hpp

@@ -10,6 +10,8 @@
 #include "duckdb/common/arrow/arrow.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/preserved_error.hpp"
+#include "duckdb/main/chunk_scan_state.hpp"
+#include "duckdb/common/arrow/arrow_options.hpp"
 
 //! Here we have the internal duckdb classes that interact with Arrow's Internal Header (i.e., duckdb/commons/arrow.hpp)
 namespace duckdb {
@@ -56,9 +58,9 @@ public:
 
 class ArrowUtil {
 public:
-	static bool TryFetchChunk(QueryResult *result, idx_t chunk_size, ArrowArray *out, idx_t &result_count,
-	                          PreservedError &error);
-	static idx_t FetchChunk(QueryResult *result, idx_t chunk_size, ArrowArray *out);
+	static bool TryFetchChunk(ChunkScanState &scan_state, ArrowOptions options, idx_t chunk_size, ArrowArray *out,
+	                          idx_t &result_count, PreservedError &error);
+	static idx_t FetchChunk(ChunkScanState &scan_state, ArrowOptions options, idx_t chunk_size, ArrowArray *out);
 
 private:
 	static bool TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &out, PreservedError &error);

package/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp

@@ -10,17 +10,21 @@
 
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/common/arrow/arrow_wrapper.hpp"
+#include "duckdb/main/chunk_scan_state.hpp"
 
 namespace duckdb {
 class ResultArrowArrayStreamWrapper {
 public:
 	explicit ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result, idx_t batch_size);
+
+public:
 	ArrowArrayStream stream;
 	unique_ptr<QueryResult> result;
 	PreservedError last_error;
 	idx_t batch_size;
 	vector<LogicalType> column_types;
 	vector<string> column_names;
+	unique_ptr<ChunkScanState> scan_state;
 
 private:
 	static int MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out);

package/src/duckdb/src/include/duckdb/common/stack_checker.hpp

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/stack_checker.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+namespace duckdb {
+
+template <class RECURSIVE_CLASS>
+class StackChecker {
+public:
+	StackChecker(RECURSIVE_CLASS &recursive_class_p, idx_t stack_usage_p)
+	    : recursive_class(recursive_class_p), stack_usage(stack_usage_p) {
+		recursive_class.stack_depth += stack_usage;
+	}
+	~StackChecker() {
+		recursive_class.stack_depth -= stack_usage;
+	}
+	StackChecker(StackChecker &&other) noexcept
+	    : recursive_class(other.recursive_class), stack_usage(other.stack_usage) {
+		other.stack_usage = 0;
+	}
+	StackChecker(const StackChecker &) = delete;
+
+private:
+	RECURSIVE_CLASS &recursive_class;
+	idx_t stack_usage;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/chunk_scan_state/query_result.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "duckdb/main/chunk_scan_state.hpp"
+#include "duckdb/common/preserved_error.hpp"
+
+namespace duckdb {
+
+class QueryResult;
+
+class QueryResultChunkScanState : public ChunkScanState {
+public:
+	QueryResultChunkScanState(QueryResult &result);
+	~QueryResultChunkScanState();
+
+public:
+	bool LoadNextChunk(PreservedError &error) override;
+	bool HasError() const override;
+	PreservedError &GetError() override;
+	const vector<LogicalType> &Types() const override;
+	const vector<string> &Names() const override;
+
+private:
+	bool InternalLoad(PreservedError &error);
+
+private:
+	QueryResult &result;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/chunk_scan_state.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/preserved_error.hpp"
+
+namespace duckdb {
+
+class DataChunk;
+
+//! Abstract chunk fetcher
+class ChunkScanState {
+public:
+	explicit ChunkScanState() {
+	}
+	virtual ~ChunkScanState() {
+	}
+
+public:
+	ChunkScanState(const ChunkScanState &other) = delete;
+	ChunkScanState(ChunkScanState &&other) = default;
+	ChunkScanState &operator=(const ChunkScanState &other) = delete;
+	ChunkScanState &operator=(ChunkScanState &&other) = default;
+
+public:
+	virtual bool LoadNextChunk(PreservedError &error) = 0;
+	virtual bool HasError() const = 0;
+	virtual PreservedError &GetError() = 0;
+	virtual const vector<LogicalType> &Types() const = 0;
+	virtual const vector<string> &Names() const = 0;
+	idx_t CurrentOffset() const;
+	idx_t RemainingInChunk() const;
+	DataChunk &CurrentChunk();
+	bool ChunkIsEmpty() const;
+	bool Finished() const;
+	bool ScanStarted() const;
+	void IncreaseOffset(idx_t increment, bool unsafe = false);
+
+protected:
+	idx_t offset = 0;
+	bool finished = false;
+	unique_ptr<DataChunk> current_chunk;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -162,6 +162,9 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
                                                          {"st_removerepeatedpoints", "spatial"},
                                                          {"st_geomfromgeojson", "spatial"},
                                                          {"st_readosm", "spatial"},
+                                                         {"st_reduceprecision", "spatial"},
+                                                         {"st_geomfromhexwkb", "spatial"},
+                                                         {"st_geomfromhexewkb", "spatial"},
                                                          {"st_numpoints", "spatial"}};
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {

package/src/duckdb/src/include/duckdb/main/query_result.hpp

@@ -63,16 +63,7 @@ protected:
 	//! The error (in case execution was not successful)
 	PreservedError error;
 };
-struct CurrentChunk {
-	//! The current data chunk
-	unique_ptr<DataChunk> data_chunk;
-	//! The current position in the data chunk
-	idx_t position;
-	//! If we have a current chunk we must scan for result production
-	bool Valid();
-	//! The remaining size of the current chunk
-	idx_t RemainingSize();
-};
+
 //! The QueryResult object holds the result of a query. It can either be a MaterializedQueryResult, in which case the
 //! result contains the entire result set, or a StreamQueryResult in which case the Fetch method can be called to
 //! incrementally fetch data from the database.
@@ -89,10 +80,6 @@ public:
 	ClientProperties client_properties;
 	//! The next result (if any)
 	unique_ptr<QueryResult> next;
-	//! In case we are converting the result from Native DuckDB to a different library (e.g., Arrow, Polars)
-	//! We might be producing chunks of a pre-determined size.
-	//! To comply, we use the following variable to store the current chunk, and it's position.
-	CurrentChunk current_chunk;
 
 public:
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/stack_checker.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/group_by_node.hpp"
@@ -26,7 +27,6 @@
 namespace duckdb {
 
 class ColumnDefinition;
-class StackChecker;
 struct OrderByNode;
 struct CopyInfo;
 struct CommonTableExpressionInfo;
@@ -39,7 +39,7 @@ struct PivotColumn;
 //! The transformer class is responsible for transforming the internal Postgres
 //! parser representation into the DuckDB representation
 class Transformer {
-	friend class StackChecker;
+	friend class StackChecker<Transformer>;
 
 	struct CreatePivotEntry {
 		string enum_name;
@@ -343,7 +343,7 @@ private:
 	idx_t stack_depth;
 
 	void InitializeStackCheck();
-	StackChecker StackCheck(idx_t extra_stack = 1);
+	StackChecker<Transformer> StackCheck(idx_t extra_stack = 1);
 
 public:
 	template <class T>
@@ -356,18 +356,6 @@ public:
 	}
 };
 
-class StackChecker {
-public:
-	StackChecker(Transformer &transformer, idx_t stack_usage);
-	~StackChecker();
-	StackChecker(StackChecker &&) noexcept;
-	StackChecker(const StackChecker &) = delete;
-
-private:
-	Transformer &transformer;
-	idx_t stack_usage;
-};
-
 vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list);
 
 } // namespace duckdb

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

@@ -9,11 +9,12 @@
 #pragma once
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/stack_checker.hpp"
+#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/tokens.hpp"
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/common/unordered_map.hpp"
 
 namespace duckdb {
 
@@ -51,6 +52,8 @@ struct BindResult {
 };
 
 class ExpressionBinder {
+	friend class StackChecker<ExpressionBinder>;
+
 public:
 	ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder = false);
 	virtual ~ExpressionBinder();
@@ -110,6 +113,15 @@ public:
 
 	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
 
+private:
+	//! Maximum stack depth
+	static constexpr const idx_t MAXIMUM_STACK_DEPTH = 128;
+	//! Current stack depth
+	idx_t stack_depth = DConstants::INVALID_INDEX;
+
+	void InitializeStackCheck();
+	StackChecker<ExpressionBinder> StackCheck(const ParsedExpression &expr, idx_t extra_stack = 1);
+
 protected:
 	BindResult BindExpression(BetweenExpression &expr, idx_t depth);
 	BindResult BindExpression(CaseExpression &expr, idx_t depth);

package/src/duckdb/src/main/chunk_scan_state/query_result.cpp

@@ -0,0 +1,53 @@
+#include "duckdb/main/query_result.hpp"
+#include "duckdb/main/stream_query_result.hpp"
+#include "duckdb/main/chunk_scan_state/query_result.hpp"
+
+namespace duckdb {
+
+QueryResultChunkScanState::QueryResultChunkScanState(QueryResult &result) : ChunkScanState(), result(result) {
+}
+
+QueryResultChunkScanState::~QueryResultChunkScanState() {
+}
+
+bool QueryResultChunkScanState::InternalLoad(PreservedError &error) {
+	D_ASSERT(!finished);
+	if (result.type == QueryResultType::STREAM_RESULT) {
+		auto &stream_result = result.Cast<StreamQueryResult>();
+		if (!stream_result.IsOpen()) {
+			return true;
+		}
+	}
+	return result.TryFetch(current_chunk, error);
+}
+
+bool QueryResultChunkScanState::HasError() const {
+	return result.HasError();
+}
+
+PreservedError &QueryResultChunkScanState::GetError() {
+	D_ASSERT(result.HasError());
+	return result.GetErrorObject();
+}
+
+const vector<LogicalType> &QueryResultChunkScanState::Types() const {
+	return result.types;
+}
+
+const vector<string> &QueryResultChunkScanState::Names() const {
+	return result.names;
+}
+
+bool QueryResultChunkScanState::LoadNextChunk(PreservedError &error) {
+	if (finished) {
+		return !finished;
+	}
+	auto load_result = InternalLoad(error);
+	if (!load_result) {
+		finished = true;
+	}
+	offset = 0;
+	return !finished;
+}
+
+} // namespace duckdb

package/src/duckdb/src/main/chunk_scan_state.cpp

@@ -0,0 +1,42 @@
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/main/chunk_scan_state.hpp"
+
+namespace duckdb {
+
+idx_t ChunkScanState::CurrentOffset() const {
+	return offset;
+}
+
+void ChunkScanState::IncreaseOffset(idx_t increment, bool unsafe) {
+	D_ASSERT(unsafe || increment <= RemainingInChunk());
+	offset += increment;
+}
+
+bool ChunkScanState::ChunkIsEmpty() const {
+	return !current_chunk || current_chunk->size() == 0;
+}
+
+bool ChunkScanState::Finished() const {
+	return finished;
+}
+
+bool ChunkScanState::ScanStarted() const {
+	return !ChunkIsEmpty();
+}
+
+DataChunk &ChunkScanState::CurrentChunk() {
+	// Scan must already be started
+	D_ASSERT(current_chunk);
+	return *current_chunk;
+}
+
+idx_t ChunkScanState::RemainingInChunk() const {
+	if (ChunkIsEmpty()) {
+		return 0;
+	}
+	D_ASSERT(current_chunk);
+	D_ASSERT(offset <= current_chunk->size());
+	return current_chunk->size() - offset;
+}
+
+} // namespace duckdb

package/src/duckdb/src/main/query_result.cpp

@@ -57,19 +57,6 @@ QueryResult::QueryResult(QueryResultType type, StatementType statement_type, Sta
       client_properties(std::move(client_properties_p)) {
 }
 
-bool CurrentChunk::Valid() {
-	if (data_chunk) {
-		if (position < data_chunk->size()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-idx_t CurrentChunk::RemainingSize() {
-	return data_chunk->size() - position;
-}
-
 QueryResult::QueryResult(QueryResultType type, PreservedError error)
     : BaseQueryResult(type, std::move(error)), client_properties("UTC", ArrowOffsetSize::REGULAR) {
 }

package/src/duckdb/src/parser/transformer.cpp

@@ -9,20 +9,6 @@
 
 namespace duckdb {
 
-StackChecker::StackChecker(Transformer &transformer_p, idx_t stack_usage_p)
-    : transformer(transformer_p), stack_usage(stack_usage_p) {
-	transformer.stack_depth += stack_usage;
-}
-
-StackChecker::~StackChecker() {
-	transformer.stack_depth -= stack_usage;
-}
-
-StackChecker::StackChecker(StackChecker &&other) noexcept
-    : transformer(other.transformer), stack_usage(other.stack_usage) {
-	other.stack_usage = 0;
-}
-
 Transformer::Transformer(ParserOptions &options)
     : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
 }
@@ -59,7 +45,7 @@ void Transformer::InitializeStackCheck() {
 	stack_depth = 0;
 }
 
-StackChecker Transformer::StackCheck(idx_t extra_stack) {
+StackChecker<Transformer> Transformer::StackCheck(idx_t extra_stack) {
 	auto &root = RootTransformer();
 	D_ASSERT(root.stack_depth != DConstants::INVALID_INDEX);
 	if (root.stack_depth + extra_stack >= options.max_expression_depth) {
@@ -67,7 +53,7 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 		                      "increase the maximum expression depth.",
 		                      options.max_expression_depth);
 	}
-	return StackChecker(root, extra_stack);
+	return StackChecker<Transformer>(root, extra_stack);
 }
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode &stmt) {

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

@@ -1,12 +1,12 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/function/scalar_macro_function.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
-#include "duckdb/function/scalar_macro_function.hpp"
-
 namespace duckdb {
 
 void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr) {
@@ -79,8 +79,10 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	new_macro_binding->arguments = &positionals;
 	macro_binding = new_macro_binding.get();
 
-	// replace current expression with stored macro expression, and replace params
+	// replace current expression with stored macro expression
 	expr = macro_def.expression->Copy();
+
+	// now replace the parameters
 	ReplaceMacroParametersRecursive(expr);
 
 	// bind the unfolded macro

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -134,33 +134,6 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 	base.types = query_node.types;
 }
 
-static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpression> &expr) {
-	switch (expr->GetExpressionClass()) {
-	case ExpressionClass::FUNCTION: {
-		auto &func = expr->Cast<FunctionExpression>();
-		auto function = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, func.catalog, func.schema,
-		                                  func.function_name, OnEntryNotFound::RETURN_NULL);
-		if (function) {
-			func.catalog = function->ParentCatalog().GetName();
-			func.schema = function->ParentSchema().name;
-		}
-		break;
-	}
-	case ExpressionClass::SUBQUERY: {
-		// replacing parameters within a subquery is slightly different
-		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
-		ParsedExpressionIterator::EnumerateQueryNodeChildren(
-		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
-		break;
-	}
-	default: // fall through
-		break;
-	}
-	// unfold child expressions
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
-}
-
 SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto &base = info.Cast<CreateMacroInfo>();
 	auto &scalar_function = base.function->Cast<ScalarMacroFunction>();
@@ -190,7 +163,6 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto this_macro_binding = make_uniq<DummyBinding>(dummy_types, dummy_names, base.name);
 	macro_binding = this_macro_binding.get();
 	ExpressionBinder::QualifyColumnNames(*this, scalar_function.expression);
-	QualifyFunctionNames(context, scalar_function.expression);
 
 	// create a copy of the expression because we do not want to alter the original
 	auto expression = scalar_function.expression->Copy();

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

@@ -10,6 +10,7 @@ namespace duckdb {
 
 ExpressionBinder::ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder)
     : binder(binder), context(context) {
+	InitializeStackCheck();
 	if (replace_binder) {
 		stored_binder = &binder.GetActiveBinder();
 		binder.SetActiveBinder(*this);
@@ -28,7 +29,26 @@ ExpressionBinder::~ExpressionBinder() {
 	}
 }
 
+void ExpressionBinder::InitializeStackCheck() {
+	if (binder.HasActiveBinder()) {
+		stack_depth = binder.GetActiveBinder().stack_depth;
+	} else {
+		stack_depth = 0;
+	}
+}
+
+StackChecker<ExpressionBinder> ExpressionBinder::StackCheck(const ParsedExpression &expr, idx_t extra_stack) {
+	D_ASSERT(stack_depth != DConstants::INVALID_INDEX);
+	if (stack_depth + extra_stack >= MAXIMUM_STACK_DEPTH) {
+		throw BinderException("Maximum recursion depth exceeded (Maximum: %llu) while binding \"%s\"",
+		                      MAXIMUM_STACK_DEPTH, expr.ToString());
+	}
+	return StackChecker<ExpressionBinder>(*this, extra_stack);
+}
+
 BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
+	auto stack_checker = StackCheck(*expr);
+
 	auto &expr_ref = *expr;
 	switch (expr_ref.expression_class) {
 	case ExpressionClass::BETWEEN:

package/src/duckdb/ub_src_main.cpp

@@ -10,6 +10,8 @@
 
 #include "src/main/client_verify.cpp"
 
+#include "src/main/chunk_scan_state.cpp"
+
 #include "src/main/config.cpp"
 
 #include "src/main/connection.cpp"

package/src/duckdb/ub_src_main_chunk_scan_state.cpp

@@ -0,0 +1,2 @@
+#include "src/main/chunk_scan_state/query_result.cpp"
+