duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

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

@@ -63,7 +63,7 @@ public:
 	//! Returns the result names of the prepared statement
 	DUCKDB_API const vector<string> &GetNames();
 	//! Returns the map of parameter index to the expected type of parameter
-	DUCKDB_API vector<LogicalType> GetExpectedParameterTypes() const;
+	DUCKDB_API case_insensitive_map_t<LogicalType> GetExpectedParameterTypes() const;
 
 	//! Create a pending query result of the prepared statement with the given set of arguments
 	template <typename... Args>
@@ -72,6 +72,20 @@ public:
 		return PendingQueryRecursive(values, args...);
 	}
 
+	//! Create a pending query result of the prepared statement with the given set of arguments
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
+
+	//! Create a pending query result of the prepared statement with the given set named arguments
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(case_insensitive_map_t<Value> &named_values,
+	                                                       bool allow_stream_result = true);
+
+	//! Execute the prepared statement with the given set of values
+	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
+
+	//! Execute the prepared statement with the given set of named+unnamed values
+	DUCKDB_API unique_ptr<QueryResult> Execute(case_insensitive_map_t<Value> &named_values,
+	                                           bool allow_stream_result = true);
+
 	//! Execute the prepared statement with the given set of arguments
 	template <typename... Args>
 	unique_ptr<QueryResult> Execute(Args... args) {
@@ -79,11 +93,65 @@ public:
 		return ExecuteRecursive(values, args...);
 	}
 
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
+	template <class PAYLOAD>
+	static string ExcessValuesException(const case_insensitive_map_t<idx_t> &parameters,
+	                                    case_insensitive_map_t<PAYLOAD> &values) {
+		// Too many values
+		set<string> excess_set;
+		for (auto &pair : values) {
+			auto &name = pair.first;
+			if (!parameters.count(name)) {
+				excess_set.insert(name);
+			}
+		}
+		vector<string> excess_values;
+		for (auto &val : excess_set) {
+			excess_values.push_back(val);
+		}
+		return StringUtil::Format("Parameter argument/count mismatch, identifiers of the excess parameters: %s",
+		                          StringUtil::Join(excess_values, ", "));
+	}
 
-	//! Execute the prepared statement with the given set of values
-	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
+	template <class PAYLOAD>
+	static string MissingValuesException(const case_insensitive_map_t<idx_t> &parameters,
+	                                     case_insensitive_map_t<PAYLOAD> &values) {
+		// Missing values
+		set<string> missing_set;
+		for (auto &pair : parameters) {
+			auto &name = pair.first;
+			if (!values.count(name)) {
+				missing_set.insert(name);
+			}
+		}
+		vector<string> missing_values;
+		for (auto &val : missing_set) {
+			missing_values.push_back(val);
+		}
+		return StringUtil::Format("Values were not provided for the following prepared statement parameters: %s",
+		                          StringUtil::Join(missing_values, ", "));
+	}
+
+	template <class PAYLOAD>
+	static void VerifyParameters(case_insensitive_map_t<PAYLOAD> &provided,
+	                             const case_insensitive_map_t<idx_t> &expected) {
+		if (expected.size() == provided.size()) {
+			// Same amount of identifiers, if
+			for (auto &pair : expected) {
+				auto &identifier = pair.first;
+				if (!provided.count(identifier)) {
+					throw InvalidInputException(MissingValuesException(expected, provided));
+				}
+			}
+			return;
+		}
+		// Mismatch in expected and provided parameters/values
+		if (expected.size() > provided.size()) {
+			throw InvalidInputException(MissingValuesException(expected, provided));
+		} else {
+			D_ASSERT(provided.size() > expected.size());
+			throw InvalidInputException(ExcessValuesException(expected, provided));
+		}
+	}
 
 private:
 	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values) {

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

@@ -31,8 +31,6 @@ public:
 	unique_ptr<SQLStatement> unbound_statement;
 	//! The fully prepared physical plan of the prepared statement
 	unique_ptr<PhysicalOperator> plan;
-	//! The map of parameter index to the actual value entry
-	bound_parameter_map_t value_map;
 
 	//! The result names of the transaction
 	vector<string> names;
@@ -45,17 +43,19 @@ public:
 	//! The catalog version of when the prepared statement was bound
 	//! If this version is lower than the current catalog version, we have to rebind the prepared statement
 	idx_t catalog_version;
+	//! The map of parameter index to the actual value entry
+	bound_parameter_map_t value_map;
 
 public:
 	void CheckParameterCount(idx_t parameter_count);
 	//! Whether or not the prepared statement data requires the query to rebound for the given parameters
-	bool RequireRebind(ClientContext &context, const vector<Value> &values);
+	bool RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<Value>> values);
 	//! Bind a set of values to the prepared statement data
-	DUCKDB_API void Bind(vector<Value> values);
+	DUCKDB_API void Bind(case_insensitive_map_t<Value> values);
 	//! Get the expected SQL Type of the bound parameter
-	DUCKDB_API LogicalType GetType(idx_t param_index);
+	DUCKDB_API LogicalType GetType(const string &identifier);
 	//! Try to get the expected SQL Type of the bound parameter
-	DUCKDB_API bool TryGetType(idx_t param_idx, LogicalType &result);
+	DUCKDB_API bool TryGetType(const string &identifier, LogicalType &result);
 };
 
 } // namespace duckdb

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

@@ -12,22 +12,13 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/common/preserved_error.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 namespace duckdb {
 struct BoxRendererConfig;
 
 enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDING_RESULT };
 
-//! A set of properties from the client context that can be used to interpret the query result
-struct ClientProperties {
-	ClientProperties(string time_zone_p, ArrowOffsetSize arrow_offset_size_p)
-	    : time_zone(std::move(time_zone_p)), arrow_offset_size(arrow_offset_size_p) {
-	}
-	string time_zone;
-	ArrowOffsetSize arrow_offset_size;
-};
-
 class BaseQueryResult {
 public:
 	//! Creates a successful query result with the specified names and types
@@ -63,16 +54,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 +71,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>
@@ -146,9 +124,6 @@ public:
 		}
 	}
 
-	static ArrowOptions GetArrowOptions(QueryResult &query_result);
-	static string GetConfigTimezone(QueryResult &query_result);
-
 private:
 	class QueryResultIterator;
 	class QueryResultRow {

package/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp

@@ -10,17 +10,20 @@
 
 #include "duckdb/main/relation.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/group_by_node.hpp"
 
 namespace duckdb {
 
 class AggregateRelation : public Relation {
 public:
 	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions);
+	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
+	                             GroupByNode groups);
 	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;
+	GroupByNode groups;
 	vector<ColumnDefinition> columns;
 	shared_ptr<Relation> child;
 

package/src/duckdb/src/include/duckdb/main/relation/cross_product_relation.hpp

@@ -9,15 +9,18 @@
 #pragma once
 
 #include "duckdb/main/relation.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 
 namespace duckdb {
 
 class CrossProductRelation : public Relation {
 public:
-	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right);
+	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
+	                                JoinRefType join_ref_type = JoinRefType::CROSS);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
+	JoinRefType ref_type;
 	vector<ColumnDefinition> columns;
 
 public:

package/src/duckdb/src/include/duckdb/main/relation/join_relation.hpp

@@ -9,21 +9,24 @@
 #pragma once
 
 #include "duckdb/main/relation.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 
 namespace duckdb {
 
 class JoinRelation : public Relation {
 public:
 	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
-	                        unique_ptr<ParsedExpression> condition, JoinType type);
+	                        unique_ptr<ParsedExpression> condition, JoinType type,
+	                        JoinRefType join_ref_type = JoinRefType::REGULAR);
 	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, vector<string> using_columns,
-	                        JoinType type);
+	                        JoinType type, JoinRefType join_ref_type = JoinRefType::REGULAR);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
 	unique_ptr<ParsedExpression> condition;
 	vector<string> using_columns;
 	JoinType join_type;
+	JoinRefType join_ref_type;
 	vector<ColumnDefinition> columns;
 
 public:

package/src/duckdb/src/include/duckdb/main/relation/read_csv_relation.hpp

@@ -8,19 +8,19 @@
 
 #pragma once
 
-#include "duckdb/execution/operator/persistent/csv_reader_options.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_reader_options.hpp"
 #include "duckdb/main/relation/table_function_relation.hpp"
 
 namespace duckdb {
 
-struct BufferedCSVReaderOptions;
+struct CSVReaderOptions;
 
 class ReadCSVRelation : public TableFunctionRelation {
 public:
-	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
-	                vector<ColumnDefinition> columns, string alias = string());
-	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
-	                BufferedCSVReaderOptions options, string alias = string());
+	ReadCSVRelation(const shared_ptr<ClientContext> &context, const string &csv_file, vector<ColumnDefinition> columns,
+	                string alias = string());
+	ReadCSVRelation(const shared_ptr<ClientContext> &context, const string &csv_file, CSVReaderOptions options,
+	                string alias = string());
 
 	string alias;
 	bool auto_detect;

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/common/enums/relation_type.hpp"
 #include "duckdb/common/winapi.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/common/named_parameter_map.hpp"
@@ -94,10 +95,11 @@ public:
 
 	// JOIN operation
 	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,
-	                                     JoinType type = JoinType::INNER);
+	                                     JoinType type = JoinType::INNER, JoinRefType ref_type = JoinRefType::REGULAR);
 
 	// CROSS PRODUCT operation
-	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other);
+	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other,
+	                                             JoinRefType join_ref_type = JoinRefType::CROSS);
 
 	// SET operations
 	DUCKDB_API shared_ptr<Relation> Union(const shared_ptr<Relation> &other);

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

@@ -68,7 +68,7 @@ struct DebugForceNoCrossProduct {
 struct OrderedAggregateThreshold {
 	static constexpr const char *Name = "ordered_aggregate_threshold"; // NOLINT
 	static constexpr const char *Description =                         // NOLINT
-	    "the number of rows to accumulate before sorting, used for tuning";
+	    "The number of rows to accumulate before sorting, used for tuning";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT; // NOLINT
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);
@@ -84,6 +84,15 @@ struct DebugAsOfIEJoin {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PreferRangeJoins {
+	static constexpr const char *Name = "prefer_range_joins";                                    // NOLINT
+	static constexpr const char *Description = "Force use of range joins with mixed predicates"; // NOLINT
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;                     // NOLINT
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct DebugWindowMode {
 	static constexpr const char *Name = "debug_window_mode";
 	static constexpr const char *Description = "DEBUG SETTING: switch window mode to use";
@@ -122,6 +131,15 @@ struct DefaultNullOrderSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct DisabledFileSystemsSetting {
+	static constexpr const char *Name = "disabled_filesystems";
+	static constexpr const char *Description = "Disable specific file systems preventing access (e.g. LocalFileSystem)";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct DisabledOptimizersSetting {
 	static constexpr const char *Name = "disabled_optimizers";
 	static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)";
@@ -170,6 +188,36 @@ struct CustomExtensionRepository {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct AutoloadExtensionRepository {
+	static constexpr const char *Name = "autoinstall_extension_repository";
+	static constexpr const char *Description =
+	    "Overrides the custom endpoint for extension installation on autoloading";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
+struct AutoinstallKnownExtensions {
+	static constexpr const char *Name = "autoinstall_known_extensions";
+	static constexpr const char *Description =
+	    "Whether known extensions are allowed to be automatically installed when a query depends on them";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
+struct AutoloadKnownExtensions {
+	static constexpr const char *Name = "autoload_known_extensions";
+	static constexpr const char *Description =
+	    "Whether known extensions are allowed to be automatically loaded when a query depends on them";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct EnableObjectCacheSetting {
 	static constexpr const char *Name = "enable_object_cache";
 	static constexpr const char *Description = "Whether or not object cache is used to cache e.g. Parquet metadata";
@@ -207,6 +255,7 @@ struct EnableProgressBarSetting {
 	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
+
 struct EnableProgressBarPrintSetting {
 	static constexpr const char *Name = "enable_progress_bar_print";
 	static constexpr const char *Description =
@@ -217,15 +266,6 @@ struct EnableProgressBarPrintSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
-struct ExperimentalParallelCSVSetting {
-	static constexpr const char *Name = "experimental_parallel_csv";
-	static constexpr const char *Description = "Whether or not to use the experimental parallel CSV reader";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(ClientContext &context);
-};
-
 struct ExplainOutputSetting {
 	static constexpr const char *Name = "explain_output";
 	static constexpr const char *Description = "Output of EXPLAIN statements (ALL, OPTIMIZED_ONLY, PHYSICAL_ONLY)";
@@ -366,10 +406,20 @@ struct PerfectHashThresholdSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PivotFilterThreshold {
+	static constexpr const char *Name = "pivot_filter_threshold";
+	static constexpr const char *Description =
+	    "The threshold to switch from using filtered aggregates to LIST with a dedicated pivot operator";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct PivotLimitSetting {
 	static constexpr const char *Name = "pivot_limit";
 	static constexpr const char *Description =
-	    "The maximum numer of pivot columns in a pivot statement (default: 100000)";
+	    "The maximum number of pivot columns in a pivot statement (default: 100000)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);
@@ -492,4 +542,14 @@ struct UsernameSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct FlushAllocatorSetting {
+	static constexpr const char *Name = "allocator_flush_threshold";
+	static constexpr const char *Description =
+	    "Peak allocation threshold at which to flush the allocator after completing a task.";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 } // namespace duckdb

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

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/column_binding_replacer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/logical_operator.hpp"
+
+namespace duckdb {
+
+struct ReplacementBinding {
+public:
+	ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding);
+	ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding, LogicalType new_type);
+
+public:
+	ColumnBinding old_binding;
+	ColumnBinding new_binding;
+
+	bool replace_type;
+	LogicalType new_type;
+};
+
+//! The ColumnBindingReplacer updates column bindings (e.g., after changing the operator plan), utility for optimizers
+class ColumnBindingReplacer : LogicalOperatorVisitor {
+public:
+	ColumnBindingReplacer();
+
+public:
+	//! Update each operator of the plan
+	void VisitOperator(LogicalOperator &op) override;
+	//! Visit an expression and update its column bindings
+	void VisitExpression(unique_ptr<Expression> *expression) override;
+
+public:
+	//! Contains all bindings that need to be updated
+	vector<ReplacementBinding> replacement_bindings;
+
+	//! Do not recurse further than this operator (optional)
+	optional_ptr<LogicalOperator> stop_operator;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/compressed_materialization.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+#include "duckdb/planner/column_binding_map.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
+
+namespace duckdb {
+
+class LogicalOperator;
+struct JoinCondition;
+
+struct CMChildInfo {
+public:
+	CMChildInfo(LogicalOperator &op, const column_binding_set_t &referenced_bindings);
+
+public:
+	//! Bindings and types before compressing
+	vector<ColumnBinding> bindings_before;
+	vector<LogicalType> &types;
+	//! Whether the input binding is eligible for compression
+	vector<bool> can_compress;
+
+	//! Bindings after compressing (projection on top)
+	vector<ColumnBinding> bindings_after;
+};
+
+struct CMBindingInfo {
+public:
+	explicit CMBindingInfo(ColumnBinding binding, const LogicalType &type);
+
+public:
+	ColumnBinding binding;
+
+	//! Type before compressing
+	LogicalType type;
+	bool needs_decompression;
+	unique_ptr<BaseStatistics> stats;
+};
+
+struct CompressedMaterializationInfo {
+public:
+	CompressedMaterializationInfo(LogicalOperator &op, vector<idx_t> &&child_idxs,
+	                              const column_binding_set_t &referenced_bindings);
+
+public:
+	//! Mapping from incoming bindings to outgoing bindings
+	column_binding_map_t<CMBindingInfo> binding_map;
+
+	//! Operator child info
+	vector<idx_t> child_idxs;
+	vector<CMChildInfo> child_info;
+};
+
+struct CompressExpression {
+public:
+	CompressExpression(unique_ptr<Expression> expression, unique_ptr<BaseStatistics> stats);
+
+public:
+	unique_ptr<Expression> expression;
+	unique_ptr<BaseStatistics> stats;
+};
+
+typedef column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map_t;
+
+//! The CompressedMaterialization optimizer compressed columns using projections, based on available statistics,
+//! but only if the data enters a materializing operator
+class CompressedMaterialization {
+public:
+	explicit CompressedMaterialization(ClientContext &context, Binder &binder, statistics_map_t &&statistics_map);
+
+	void Compress(unique_ptr<LogicalOperator> &op);
+
+private:
+	//! Depth-first traversal of the plan
+	void CompressInternal(unique_ptr<LogicalOperator> &op);
+
+	//! Compress materializing operators
+	void CompressAggregate(unique_ptr<LogicalOperator> &op);
+	void CompressDistinct(unique_ptr<LogicalOperator> &op);
+	void CompressOrder(unique_ptr<LogicalOperator> &op);
+
+	//! Update statistics after compressing
+	void UpdateAggregateStats(unique_ptr<LogicalOperator> &op);
+	void UpdateOrderStats(unique_ptr<LogicalOperator> &op);
+
+	//! Adds bindings referenced in expression to referenced_bindings
+	static void GetReferencedBindings(const Expression &expression, column_binding_set_t &referenced_bindings);
+	//! Updates CMBindingInfo in the binding_map in info
+	void UpdateBindingInfo(CompressedMaterializationInfo &info, const ColumnBinding &binding, bool needs_decompression);
+
+	//! Create (de)compress projections around the operator
+	void CreateProjections(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
+	bool TryCompressChild(CompressedMaterializationInfo &info, const CMChildInfo &child_info,
+	                      vector<unique_ptr<CompressExpression>> &compress_expressions);
+	void CreateCompressProjection(unique_ptr<LogicalOperator> &child_op,
+	                              vector<unique_ptr<CompressExpression>> &&compress_exprs,
+	                              CompressedMaterializationInfo &info, CMChildInfo &child_info);
+	void CreateDecompressProjection(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
+
+	//! Create expressions that apply a scalar compression function
+	unique_ptr<CompressExpression> GetCompressExpression(const ColumnBinding &binding, const LogicalType &type,
+	                                                     const bool &can_compress);
+	unique_ptr<CompressExpression> GetCompressExpression(unique_ptr<Expression> input, const BaseStatistics &stats);
+	unique_ptr<CompressExpression> GetIntegralCompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+	unique_ptr<CompressExpression> GetStringCompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+
+	//! Create an expression that applies a scalar decompression function
+	unique_ptr<Expression> GetDecompressExpression(unique_ptr<Expression> input, const LogicalType &result_type,
+	                                               const BaseStatistics &stats);
+	unique_ptr<Expression> GetIntegralDecompress(unique_ptr<Expression> input, const LogicalType &result_type,
+	                                             const BaseStatistics &stats);
+	unique_ptr<Expression> GetStringDecompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+
+private:
+	ClientContext &context;
+	Binder &binder;
+	statistics_map_t statistics_map;
+	unordered_set<idx_t> compression_table_indices;
+	unordered_set<idx_t> decompression_table_indices;
+	optional_ptr<LogicalOperator> root;
+};
+
+} // namespace duckdb