duckdb 0.7.2-dev2320.0 → 0.7.2-dev2366.0

package/src/duckdb/src/include/duckdb/common/crypto/md5.hpp

@@ -26,7 +26,7 @@ public:
 	}
 	void Add(const char *data);
 	void Add(string_t string) {
-		MD5Update((const_data_ptr_t)string.GetDataUnsafe(), string.GetSize());
+		MD5Update((const_data_ptr_t)string.GetData(), string.GetSize());
 	}
 	void Add(const string &data) {
 		MD5Update((const_data_ptr_t)data.c_str(), data.size());

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

@@ -50,7 +50,7 @@ public:
 
 	static inline void EncodeStringDataPrefix(data_ptr_t dataptr, string_t value, idx_t prefix_len) {
 		auto len = value.GetSize();
-		memcpy(dataptr, value.GetDataUnsafe(), MinValue(len, prefix_len));
+		memcpy(dataptr, value.GetData(), MinValue(len, prefix_len));
 		if (len < prefix_len) {
 			memset(dataptr + len, '\0', prefix_len - len);
 		}

package/src/duckdb/src/include/duckdb/common/types/string_type.hpp

@@ -68,10 +68,12 @@ public:
 		return GetSize() <= INLINE_LENGTH;
 	}
 
-	//! this is unsafe since the string will not be terminated at the end
-	const char *GetDataUnsafe() const {
+	const char *GetData() const {
 		return IsInlined() ? (const char *)value.inlined.inlined : value.pointer.ptr;
 	}
+	const char *GetDataUnsafe() const {
+		return GetData();
+	}
 
 	char *GetDataWriteable() const {
 		return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr;
@@ -86,7 +88,7 @@ public:
 	}
 
 	string GetString() const {
-		return string(GetDataUnsafe(), GetSize());
+		return string(GetData(), GetSize());
 	}
 
 	explicit operator string() const {
@@ -108,7 +110,7 @@ public:
 		} else {
 			// copy the data into the prefix
 #ifndef DUCKDB_DEBUG_NO_INLINE
-			auto dataptr = (char *)GetDataUnsafe();
+			auto dataptr = (char *)GetData();
 			memcpy(value.pointer.prefix, dataptr, PREFIX_LENGTH);
 #else
 			memset(value.pointer.prefix, 0, PREFIX_BYTES);
@@ -124,7 +126,7 @@ public:
 #ifdef DUCKDB_DEBUG_NO_INLINE
 			if (a.GetSize() != b.GetSize())
 				return false;
-			return (memcmp(a.GetDataUnsafe(), b.GetDataUnsafe(), a.GetSize()) == 0);
+			return (memcmp(a.GetData(), b.GetData(), a.GetSize()) == 0);
 #endif
 			uint64_t A = Load<uint64_t>((const_data_ptr_t)&a);
 			uint64_t B = Load<uint64_t>((const_data_ptr_t)&b);
@@ -177,7 +179,7 @@ public:
 			if (A != B)
 				return bswap(A) > bswap(B);
 #endif
-			auto memcmp_res = memcmp(left.GetDataUnsafe(), right.GetDataUnsafe(), min_length);
+			auto memcmp_res = memcmp(left.GetData(), right.GetData(), min_length);
 			return memcmp_res > 0 || (memcmp_res == 0 && left_length > right_length);
 		}
 	};

package/src/duckdb/src/include/duckdb/common/types/vector_buffer.hpp

@@ -143,7 +143,7 @@ public:
 		return heap.AddString(data);
 	}
 	string_t AddBlob(string_t data) {
-		return heap.AddBlob(data.GetDataUnsafe(), data.GetSize());
+		return heap.AddBlob(data.GetData(), data.GetSize());
 	}
 	string_t EmptyString(idx_t len) {
 		return heap.EmptyString(len);

package/src/duckdb/src/include/duckdb/function/macro_function.hpp

@@ -44,6 +44,23 @@ public:
 	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
 
 	virtual string ToSQL(const string &schema, const string &name) const;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast macro to type - macro type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast macro to type - macro type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/regexp.hpp

@@ -22,7 +22,7 @@ void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result,
 void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace = nullptr);
 
 inline duckdb_re2::StringPiece CreateStringPiece(const string_t &input) {
-	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
+	return duckdb_re2::StringPiece(input.GetData(), input.GetSize());
 }
 
 inline string_t Extract(const string_t &input, Vector &result, const RE2 &re, const duckdb_re2::StringPiece &rewrite) {

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -58,7 +58,7 @@ struct LengthFun {
 
 	template <class TA, class TR>
 	static inline TR Length(TA input) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		TR length = 0;
 		for (idx_t i = 0; i < input_length; i++) {
@@ -69,7 +69,7 @@ struct LengthFun {
 
 	template <class TA, class TR>
 	static inline TR GraphemeCount(TA input) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		for (idx_t i = 0; i < input_length; i++) {
 			if (input_data[i] & 0x80) {

package/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp

@@ -19,6 +19,9 @@
 namespace duckdb {
 
 class ScalarMacroFunction : public MacroFunction {
+public:
+	static constexpr const MacroType TYPE = MacroType::SCALAR_MACRO;
+
 public:
 	ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
 

package/src/duckdb/src/include/duckdb/function/table_macro_function.hpp

@@ -19,6 +19,9 @@
 namespace duckdb {
 
 class TableMacroFunction : public MacroFunction {
+public:
+	static constexpr const MacroType TYPE = MacroType::TABLE_MACRO;
+
 public:
 	explicit TableMacroFunction(unique_ptr<QueryNode> query_node);
 	TableMacroFunction(void);

package/src/duckdb/src/include/duckdb/main/capi/cast/utils.hpp

@@ -80,7 +80,7 @@ struct ToCStringCastWrapper {
 		Vector result_vector(LogicalType::VARCHAR, nullptr);
 		auto result_string = OP::template Operation<SOURCE_TYPE>(input, result_vector);
 		auto result_size = result_string.GetSize();
-		auto result_data = result_string.GetDataUnsafe();
+		auto result_data = result_string.GetData();
 
 		char *allocated_data = (char *)duckdb_malloc(result_size + 1);
 		memcpy(allocated_data, result_data, result_size);

package/src/duckdb/src/include/duckdb/optimizer/cse_optimizer.hpp

@@ -30,7 +30,7 @@ private:
 	//! First iteration: count how many times each expression occurs
 	void CountExpressions(Expression &expr, CSEReplacementState &state);
 	//! Second iteration: perform the actual replacement of the duplicate expressions with common subexpressions nodes
-	void PerformCSEReplacement(unique_ptr<Expression> *expr, CSEReplacementState &state);
+	void PerformCSEReplacement(unique_ptr<Expression> &expr, CSEReplacementState &state);
 
 	//! Main method to extract common subexpressions
 	void ExtractCommonSubExpresions(LogicalOperator &op);

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

@@ -184,6 +184,7 @@ private:
 	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a QueryNode
 	unique_ptr<QueryNode> TransformSelectNode(duckdb_libpgquery::PGSelectStmt *node);
 	unique_ptr<QueryNode> TransformSelectInternal(duckdb_libpgquery::PGSelectStmt *node);
+	void TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, QueryNode &node);
 
 	//===--------------------------------------------------------------------===//
 	// Expression Transform

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

@@ -321,7 +321,7 @@ private:
 
 	unique_ptr<LogicalOperator> PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root);
 
-	void PlanSubqueries(unique_ptr<Expression> *expr, unique_ptr<LogicalOperator> *root);
+	void PlanSubqueries(unique_ptr<Expression> &expr, unique_ptr<LogicalOperator> &root);
 	unique_ptr<Expression> PlanSubquery(BoundSubqueryExpression &expr, unique_ptr<LogicalOperator> &root);
 	unique_ptr<LogicalOperator> PlanLateralJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
 	                                            vector<CorrelatedColumnInfo> &correlated_columns,

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

@@ -21,7 +21,7 @@ public:
 	AggregateBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

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

@@ -24,7 +24,7 @@ public:
 	vector<LogicalIndex> &bound_columns;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	BindResult BindColumn(ColumnRefExpression &expr);

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

@@ -40,10 +40,11 @@ public:
 	}
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
-	BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function, idx_t depth) override;
+	BindResult BindAggregate(FunctionExpression &expr, optional_ptr<AggregateFunctionCatalogEntry> function,
+	                         idx_t depth) override;
 
 	bool inside_window;
 	bool bound_aggregate = false;
@@ -53,7 +54,7 @@ protected:
 	case_insensitive_map_t<idx_t> alias_map;
 
 protected:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth);
 	BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth) override;
 	BindResult BindWindow(WindowExpression &expr, idx_t depth);
 

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

@@ -25,7 +25,7 @@ public:
 	physical_index_set_t &bound_columns;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	BindResult BindCheckColumn(ColumnRefExpression &expr);

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

@@ -21,7 +21,7 @@ public:
 	string clause;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
 };

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

@@ -27,7 +27,7 @@ public:
 	idx_t bind_index;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) override;
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
 
 	string UnsupportedAggregateMessage() override;
 

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

@@ -21,11 +21,11 @@ public:
 	             case_insensitive_map_t<idx_t> &alias_map, AggregateHandling aggregate_handling);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 
 	ColumnAliasBinder column_alias_binder;
 	AggregateHandling aggregate_handling;

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

@@ -23,7 +23,7 @@ public:
 	            optional_ptr<CreateIndexInfo> info = nullptr);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 	string UnsupportedAggregateMessage() override;
 

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

@@ -18,7 +18,7 @@ public:
 	InsertBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

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

@@ -29,13 +29,13 @@ public:
 	static void ReduceExpressionDepth(LogicalOperator &op, const vector<CorrelatedColumnInfo> &info);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 	void ExtractCorrelatedColumns(Expression &expr);
 
 private:

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

@@ -20,11 +20,11 @@ public:
 	              case_insensitive_map_t<idx_t> &alias_map);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 
 	ColumnAliasBinder column_alias_binder;
 };

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

@@ -20,7 +20,7 @@ public:
 	string op;
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

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

@@ -18,7 +18,7 @@ public:
 	ReturningBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 };
 

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

@@ -19,7 +19,7 @@ public:
 
 protected:
 	BindResult BindColumnReference(ColumnRefExpression &expr, idx_t depth, bool root_expression);
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
 };

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

@@ -18,7 +18,7 @@ public:
 	UpdateBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

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

@@ -20,13 +20,13 @@ public:
 	WhereBinder(Binder &binder, ClientContext &context, optional_ptr<ColumnAliasBinder> column_alias_binder = nullptr);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 
 	optional_ptr<ColumnAliasBinder> column_alias_binder;
 };

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

@@ -63,7 +63,7 @@ public:
 	optional_ptr<vector<DummyBinding>> lambda_bindings;
 
 public:
-	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> &expr, LogicalType *result_type = nullptr,
+	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> &expr, optional_ptr<LogicalType> result_type = nullptr,
 	                            bool root_expression = true);
 
 	//! Returns whether or not any columns have been bound by the expression binder
@@ -74,7 +74,7 @@ public:
 		return bound_columns;
 	}
 
-	string Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false);
+	string Bind(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false);
 
 	unique_ptr<ParsedExpression> CreateStructExtract(unique_ptr<ParsedExpression> base, string field_name);
 	unique_ptr<ParsedExpression> CreateStructPack(ColumnRefExpression &colref);
@@ -103,7 +103,7 @@ public:
 
 	//! Bind the given expresion. Unlike Bind(), this does *not* mute the given ParsedExpression.
 	//! Exposed to be used from sub-binders that aren't subclasses of ExpressionBinder.
-	virtual BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	virtual BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                                  bool root_expression = false);
 
 	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
@@ -117,7 +117,7 @@ protected:
 	BindResult BindExpression(ComparisonExpression &expr, idx_t depth);
 	BindResult BindExpression(ConjunctionExpression &expr, idx_t depth);
 	BindResult BindExpression(ConstantExpression &expr, idx_t depth);
-	BindResult BindExpression(FunctionExpression &expr, idx_t depth, unique_ptr<ParsedExpression> *expr_ptr);
+	BindResult BindExpression(FunctionExpression &expr, idx_t depth, unique_ptr<ParsedExpression> &expr_ptr);
 	BindResult BindExpression(LambdaExpression &expr, idx_t depth, const bool is_lambda,
 	                          const LogicalType &list_child_type);
 	BindResult BindExpression(OperatorExpression &expr, idx_t depth);
@@ -134,12 +134,15 @@ protected:
 
 protected:
 	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);
-	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry *function, idx_t depth);
-	virtual BindResult BindLambdaFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry *function, idx_t depth);
-	virtual BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function, idx_t depth);
+	virtual BindResult BindFunction(FunctionExpression &expr, optional_ptr<ScalarFunctionCatalogEntry> function,
+	                                idx_t depth);
+	virtual BindResult BindLambdaFunction(FunctionExpression &expr, optional_ptr<ScalarFunctionCatalogEntry> function,
+	                                      idx_t depth);
+	virtual BindResult BindAggregate(FunctionExpression &expr, optional_ptr<AggregateFunctionCatalogEntry> function,
+	                                 idx_t depth);
 	virtual BindResult BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression);
-	virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry *macro, idx_t depth,
-	                             unique_ptr<ParsedExpression> *expr_ptr);
+	virtual BindResult BindMacro(FunctionExpression &expr, optional_ptr<ScalarMacroCatalogEntry> macro, idx_t depth,
+	                             unique_ptr<ParsedExpression> &expr_ptr);
 
 	virtual string UnsupportedAggregateMessage();
 	virtual string UnsupportedUnnestMessage();

package/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp

@@ -155,7 +155,7 @@ public:
 				remaining_space -= required_space;
 				auto dict_pos = end - *dictionary_size;
 				// now write the actual string data into the dictionary
-				memcpy(dict_pos, source_data[source_idx].GetDataUnsafe(), string_length);
+				memcpy(dict_pos, source_data[source_idx].GetData(), string_length);
 
 				// place the dictionary offset into the set of vectors
 				result_data[target_idx] = *dictionary_size;

package/src/duckdb/src/main/capi/cast/from_decimal-c.cpp

@@ -35,7 +35,7 @@ bool CastDecimalCInternal(duckdb_result *source, duckdb_string &result, idx_t co
 		throw duckdb::InternalException("Unimplemented internal type for decimal");
 	}
 	result.data = (char *)duckdb_malloc(sizeof(char) * (result_string.GetSize() + 1));
-	memcpy(result.data, result_string.GetDataUnsafe(), result_string.GetSize());
+	memcpy(result.data, result_string.GetData(), result_string.GetSize());
 	result.data[result_string.GetSize()] = '\0';
 	result.size = result_string.GetSize();
 	return true;

package/src/duckdb/src/main/capi/result-c.cpp

@@ -21,7 +21,7 @@ struct CStringConverter {
 	static DST Convert(SRC input) {
 		auto result = (char *)duckdb_malloc(input.GetSize() + 1);
 		assert(result);
-		memcpy((void *)result, input.GetDataUnsafe(), input.GetSize());
+		memcpy((void *)result, input.GetData(), input.GetSize());
 		auto write_arr = (char *)result;
 		write_arr[input.GetSize()] = '\0';
 		return result;
@@ -40,7 +40,7 @@ struct CBlobConverter {
 		result.data = (char *)duckdb_malloc(input.GetSize());
 		result.size = input.GetSize();
 		assert(result.data);
-		memcpy((void *)result.data, input.GetDataUnsafe(), input.GetSize());
+		memcpy((void *)result.data, input.GetData(), input.GetSize());
 		return result;
 	}
 

package/src/duckdb/src/optimizer/cse_optimizer.cpp

@@ -73,8 +73,8 @@ void CommonSubExpressionOptimizer::CountExpressions(Expression &expr, CSEReplace
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { CountExpressions(child, state); });
 }
 
-void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression> *expr_ptr, CSEReplacementState &state) {
-	Expression &expr = **expr_ptr;
+void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression> &expr_ptr, CSEReplacementState &state) {
+	Expression &expr = *expr_ptr;
 	if (expr.expression_class == ExpressionClass::BOUND_COLUMN_REF) {
 		auto &bound_column_ref = expr.Cast<BoundColumnRefExpression>();
 		// bound column ref, check if this one has already been recorded in the expression list
@@ -105,20 +105,20 @@ void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression>
 			if (node.column_index == DConstants::INVALID_INDEX) {
 				// has not been pushed yet: push it
 				node.column_index = state.expressions.size();
-				state.expressions.push_back(std::move(*expr_ptr));
+				state.expressions.push_back(std::move(expr_ptr));
 			} else {
-				state.cached_expressions.push_back(std::move(*expr_ptr));
+				state.cached_expressions.push_back(std::move(expr_ptr));
 			}
 			// replace the original expression with a bound column ref
-			*expr_ptr = make_uniq<BoundColumnRefExpression>(alias, type,
-			                                                ColumnBinding(state.projection_index, node.column_index));
+			expr_ptr = make_uniq<BoundColumnRefExpression>(alias, type,
+			                                               ColumnBinding(state.projection_index, node.column_index));
 			return;
 		}
 	}
 	// this expression only occurs once, we can't perform CSE elimination
 	// look into the children to see if we can replace them
 	ExpressionIterator::EnumerateChildren(expr,
-	                                      [&](unique_ptr<Expression> &child) { PerformCSEReplacement(&child, state); });
+	                                      [&](unique_ptr<Expression> &child) { PerformCSEReplacement(child, state); });
 }
 
 void CommonSubExpressionOptimizer::ExtractCommonSubExpresions(LogicalOperator &op) {
@@ -143,8 +143,9 @@ void CommonSubExpressionOptimizer::ExtractCommonSubExpresions(LogicalOperator &o
 	state.projection_index = binder.GenerateTableIndex();
 	// we found common subexpressions to extract
 	// now we iterate over all the expressions and perform the actual CSE elimination
+
 	LogicalOperatorVisitor::EnumerateExpressions(
-	    op, [&](unique_ptr<Expression> *child) { PerformCSEReplacement(child, state); });
+	    op, [&](unique_ptr<Expression> *child) { PerformCSEReplacement(*child, state); });
 	D_ASSERT(state.expressions.size() > 0);
 	// create a projection node as the child of this node
 	auto projection = make_uniq<LogicalProjection>(state.projection_index, std::move(state.expressions));

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -77,7 +77,7 @@ unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type
 void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
 	serializer.WriteProperty("subquery_type", subquery_type);
-	serializer.WriteProperty("subquery", *subquery.get());
+	serializer.WriteProperty("subquery", *subquery);
 	serializer.WriteOptionalProperty("child", child);
 	serializer.WriteProperty("comparison_type", comparison_type);
 }

package/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp

@@ -176,6 +176,8 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	}
 	pivot_ref->pivots = std::move(columns);
 	select_node->from_table = std::move(pivot_ref);
+	// transform order by/limit modifiers
+	TransformModifiers(*stmt, *select_node);
 	return std::move(select_node);
 }
 

package/src/duckdb/src/parser/transform/statement/transform_select_node.cpp

@@ -8,6 +8,38 @@
 
 namespace duckdb {
 
+void Transformer::TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, QueryNode &node) {
+	// transform the common properties
+	// both the set operations and the regular select can have an ORDER BY/LIMIT attached to them
+	vector<OrderByNode> orders;
+	TransformOrderBy(stmt.sortClause, orders);
+	if (!orders.empty()) {
+		auto order_modifier = make_uniq<OrderModifier>();
+		order_modifier->orders = std::move(orders);
+		node.modifiers.push_back(std::move(order_modifier));
+	}
+	if (stmt.limitCount || stmt.limitOffset) {
+		if (stmt.limitCount && stmt.limitCount->type == duckdb_libpgquery::T_PGLimitPercent) {
+			auto limit_percent_modifier = make_uniq<LimitPercentModifier>();
+			auto expr_node = reinterpret_cast<duckdb_libpgquery::PGLimitPercent *>(stmt.limitCount)->limit_percent;
+			limit_percent_modifier->limit = TransformExpression(expr_node);
+			if (stmt.limitOffset) {
+				limit_percent_modifier->offset = TransformExpression(stmt.limitOffset);
+			}
+			node.modifiers.push_back(std::move(limit_percent_modifier));
+		} else {
+			auto limit_modifier = make_uniq<LimitModifier>();
+			if (stmt.limitCount) {
+				limit_modifier->limit = TransformExpression(stmt.limitCount);
+			}
+			if (stmt.limitOffset) {
+				limit_modifier->offset = TransformExpression(stmt.limitOffset);
+			}
+			node.modifiers.push_back(std::move(limit_modifier));
+		}
+	}
+}
+
 unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PGSelectStmt *stmt) {
 	D_ASSERT(stmt->type == duckdb_libpgquery::T_PGSelectStmt);
 	auto stack_checker = StackCheck();
@@ -119,35 +151,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	default:
 		throw NotImplementedException("Statement type %d not implemented!", stmt->op);
 	}
-	// transform the common properties
-	// both the set operations and the regular select can have an ORDER BY/LIMIT attached to them
-	vector<OrderByNode> orders;
-	TransformOrderBy(stmt->sortClause, orders);
-	if (!orders.empty()) {
-		auto order_modifier = make_uniq<OrderModifier>();
-		order_modifier->orders = std::move(orders);
-		node->modifiers.push_back(std::move(order_modifier));
-	}
-	if (stmt->limitCount || stmt->limitOffset) {
-		if (stmt->limitCount && stmt->limitCount->type == duckdb_libpgquery::T_PGLimitPercent) {
-			auto limit_percent_modifier = make_uniq<LimitPercentModifier>();
-			auto expr_node = reinterpret_cast<duckdb_libpgquery::PGLimitPercent *>(stmt->limitCount)->limit_percent;
-			limit_percent_modifier->limit = TransformExpression(expr_node);
-			if (stmt->limitOffset) {
-				limit_percent_modifier->offset = TransformExpression(stmt->limitOffset);
-			}
-			node->modifiers.push_back(std::move(limit_percent_modifier));
-		} else {
-			auto limit_modifier = make_uniq<LimitModifier>();
-			if (stmt->limitCount) {
-				limit_modifier->limit = TransformExpression(stmt->limitCount);
-			}
-			if (stmt->limitOffset) {
-				limit_modifier->offset = TransformExpression(stmt->limitOffset);
-			}
-			node->modifiers.push_back(std::move(limit_modifier));
-		}
-	}
+	TransformModifiers(*stmt, *node);
 	return node;
 }