duckdb 1.4.0 → 1.4.1

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

@@ -318,6 +318,8 @@ public:
 	//! Transforms an complex JSON to a JSON string
 	DUCKDB_API static string ToComplexJSONMap(const ComplexJSON &complex_json);
 
+	DUCKDB_API static string ValidateJSON(const char *data, const idx_t &len);
+
 	DUCKDB_API static string GetFileName(const string &file_path);
 	DUCKDB_API static string GetFileExtension(const string &file_name);
 	DUCKDB_API static string GetFileStem(const string &file_name);

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

@@ -11,6 +11,7 @@
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/map.hpp"
 #include "duckdb/common/unordered_set.hpp"
+#include "duckdb/main/extension_helper.hpp"
 
 namespace duckdb {
 
@@ -82,8 +83,10 @@ protected:
 	}
 
 private:
+	FileSystem &FindFileSystem(const string &path, optional_ptr<FileOpener> file_opener);
+	FileSystem &FindFileSystem(const string &path, optional_ptr<DatabaseInstance> database_instance);
 	FileSystem &FindFileSystem(const string &path);
-	FileSystem &FindFileSystemInternal(const string &path);
+	optional_ptr<FileSystem> FindFileSystemInternal(const string &path);
 
 private:
 	vector<unique_ptr<FileSystem>> sub_systems;

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

@@ -29,7 +29,7 @@ struct VariantTypeofFun {
 	static constexpr const char *Name = "variant_typeof";
 	static constexpr const char *Parameters = "input_variant";
 	static constexpr const char *Description = "Returns the internal type of the `input_variant`.";
-	static constexpr const char *Example = "variant_typeof({'a': 42, 'b': [1,2,3])::VARIANT)";
+	static constexpr const char *Example = "variant_typeof({'a': 42, 'b': [1,2,3]})::VARIANT)";
 	static constexpr const char *Categories = "variant";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/function/table/system_functions.hpp

@@ -47,6 +47,10 @@ struct DuckDBSchemasFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct DuckDBConnectionCountFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct DuckDBApproxDatabaseCountFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

package/src/duckdb/src/include/duckdb/logging/log_storage.hpp

@@ -33,7 +33,7 @@ struct CSVReaderOptions;
 
 //! Logging storage can store entries normalized or denormalized. This enum describes what a single table/file/etc
 //! contains
-enum class LoggingTargetTable {
+enum class LoggingTargetTable : uint8_t {
 	ALL_LOGS,     // Denormalized: log entries consisting of both the full log entry and the context
 	LOG_ENTRIES,  // Normalized: contains only the log entries and a context_id
 	LOG_CONTEXTS, // Normalized: contains only the log contexts
@@ -165,7 +165,7 @@ private:
 	//! Debug option for testing buffering behaviour
 	bool only_flush_on_full_buffer = false;
 	//! The buffers used for each table
-	unordered_map<LoggingTargetTable, unique_ptr<DataChunk>> buffers;
+	map<LoggingTargetTable, unique_ptr<DataChunk>> buffers;
 	//! This flag is set whenever a new context_is written to the entry buffer. It means that the next flush of
 	//! LoggingTargetTable::LOG_ENTRIES also requires a flush of LoggingTargetTable::LOG_CONTEXTS
 	bool flush_contexts_on_next_entry_flush = false;
@@ -218,9 +218,9 @@ private:
 	void InitializeCastChunk(LoggingTargetTable table);
 
 	//! The cast buffers used to cast from the original types to the VARCHAR types ready to write to CSV format
-	unordered_map<LoggingTargetTable, unique_ptr<DataChunk>> cast_buffers;
+	map<LoggingTargetTable, unique_ptr<DataChunk>> cast_buffers;
 	//! The writers to be registered by child classes
-	unordered_map<LoggingTargetTable, unique_ptr<CSVWriter>> writers;
+	map<LoggingTargetTable, unique_ptr<CSVWriter>> writers;
 
 	//! CSV Options to initialize the CSVWriters with. TODO: cleanup, this is now a little bit of a mixed bag of
 	//! settings
@@ -302,7 +302,7 @@ private:
 	};
 
 	//! The table info per table
-	unordered_map<LoggingTargetTable, TableWriter> tables;
+	map<LoggingTargetTable, TableWriter> tables;
 
 	//! Base path to generate the file paths from
 	string base_path;
@@ -349,7 +349,7 @@ private:
 	//! Helper function to get the buffer
 	ColumnDataCollection &GetBuffer(LoggingTargetTable table) const;
 
-	unordered_map<LoggingTargetTable, unique_ptr<ColumnDataCollection>> log_storage_buffers;
+	map<LoggingTargetTable, unique_ptr<ColumnDataCollection>> log_storage_buffers;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/logging/log_type.hpp

@@ -17,6 +17,9 @@ struct FileHandle;
 struct BaseRequest;
 struct HTTPResponse;
 class PhysicalOperator;
+class AttachedDatabase;
+class RowGroup;
+struct DataTableInfo;
 
 //! Log types provide some structure to the formats that the different log messages can have
 //! For now, this holds a type that the VARCHAR value will be auto-cast into.
@@ -54,9 +57,7 @@ public:
 
 	QueryLogType() : LogType(NAME, LEVEL) {};
 
-	static string ConstructLogMessage(const string &str) {
-		return str;
-	}
+	static string ConstructLogMessage(const string &str);
 };
 
 class FileSystemLogType : public LogType {
@@ -105,4 +106,26 @@ public:
 	                                  const vector<pair<string, string>> &info);
 };
 
+class CheckpointLogType : public LogType {
+public:
+	static constexpr const char *NAME = "Checkpoint";
+	static constexpr LogLevel LEVEL = LogLevel::LOG_DEBUG;
+
+	//! Construct the log type
+	CheckpointLogType();
+
+	static LogicalType GetLogType();
+
+	//! Vacuum
+	static string ConstructLogMessage(const AttachedDatabase &db, DataTableInfo &table, idx_t segment_idx,
+	                                  idx_t merge_count, idx_t target_count, idx_t merge_rows, idx_t row_start);
+	//! Checkpoint
+	static string ConstructLogMessage(const AttachedDatabase &db, DataTableInfo &table, idx_t segment_idx,
+	                                  RowGroup &row_group);
+
+private:
+	static string CreateLog(const AttachedDatabase &db, DataTableInfo &table, const char *op, vector<Value> map_keys,
+	                        vector<Value> map_values);
+};
+
 } // namespace duckdb

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

@@ -40,6 +40,9 @@ struct StoredDatabasePath {
 
 	DatabaseFilePathManager &manager;
 	string path;
+
+public:
+	void OnDetach();
 };
 
 //! AttachOptions holds information about a database we plan to attach. These options are generalized, i.e.,
@@ -103,6 +106,7 @@ public:
 	void SetInitialDatabase();
 	void SetReadOnlyDatabase();
 	void OnDetach(ClientContext &context);
+	string StoredPath() const;
 
 	static bool NameIsReserved(const string &name);
 	static string ExtractDatabaseName(const string &dbpath, FileSystem &fs);

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

@@ -304,6 +304,8 @@ private:
 	CreatePreparedStatementInternal(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
 	                                optional_ptr<case_insensitive_map_t<BoundParameterData>> values);
 
+	SettingLookupResult TryGetCurrentSettingInternal(const string &key, Value &result) const;
+
 private:
 	//! Lock on using the ClientContext in parallel
 	mutex context_lock;

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

@@ -50,7 +50,6 @@ public:
 	DUCKDB_API ~Connection();
 
 	shared_ptr<ClientContext> context;
-	warning_callback_t warning_cb;
 
 public:
 	//! Returns query profiling information for the current query

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

@@ -40,7 +40,6 @@ private:
 	mutex connections_lock;
 	reference_map_t<ClientContext, weak_ptr<ClientContext>> connections;
 	atomic<idx_t> connection_count;
-
 	atomic<connection_t> current_connection_id;
 };
 

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

@@ -19,13 +19,24 @@ struct AttachOptions;
 
 enum class InsertDatabasePathResult { SUCCESS, ALREADY_EXISTS };
 
+struct DatabasePathInfo {
+	explicit DatabasePathInfo(string name_p) : name(std::move(name_p)), is_attached(true) {
+	}
+
+	string name;
+	bool is_attached;
+};
+
 //! The DatabaseFilePathManager is used to ensure we only ever open a single database file once
 class DatabaseFilePathManager {
 public:
 	idx_t ApproxDatabaseCount() const;
 	InsertDatabasePathResult InsertDatabasePath(const string &path, const string &name, OnCreateConflict on_conflict,
 	                                            AttachOptions &options);
+	//! Erase a database path - indicating we are done with using it
 	void EraseDatabasePath(const string &path);
+	//! Called when a database is detached, but before it is fully finished being used
+	void DetachDatabase(const string &path);
 
 private:
 	//! The lock to add entries to the database path map
@@ -33,7 +44,7 @@ private:
 	//! A set containing all attached database path
 	//! This allows to attach many databases efficiently, and to avoid attaching the
 	//! same file path twice
-	case_insensitive_map_t<string> db_paths_to_name;
+	case_insensitive_map_t<DatabasePathInfo> db_paths;
 };
 
 } // namespace duckdb

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

@@ -48,6 +48,7 @@ public:
 	void FinalizeStartup();
 	//! Get an attached database by its name
 	optional_ptr<AttachedDatabase> GetDatabase(ClientContext &context, const string &name);
+	shared_ptr<AttachedDatabase> GetDatabase(const string &name);
 	//! Attach a new database
 	shared_ptr<AttachedDatabase> AttachDatabase(ClientContext &context, AttachInfo &info, AttachOptions &options);
 
@@ -103,6 +104,8 @@ public:
 	//! Gets a list of all attached database paths
 	vector<string> GetAttachedDatabasePaths();
 
+	shared_ptr<AttachedDatabase> GetDatabaseInternal(const lock_guard<mutex> &, const string &name);
+
 private:
 	//! The system database is a special database that holds system entries (e.g. functions)
 	shared_ptr<AttachedDatabase> system;

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

@@ -26,6 +26,8 @@ public:
 
 public:
 	BoundStatement Bind(Binder &binder) override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	bool IsReadOnly() override {

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

@@ -26,6 +26,8 @@ public:
 
 public:
 	BoundStatement Bind(Binder &binder) override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	bool IsReadOnly() override {

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

@@ -26,6 +26,8 @@ public:
 
 public:
 	BoundStatement Bind(Binder &binder) override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	bool IsReadOnly() override {

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

@@ -24,6 +24,8 @@ public:
 
 public:
 	BoundStatement Bind(Binder &binder) override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	bool IsReadOnly() override {

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

@@ -23,6 +23,8 @@ public:
 
 public:
 	BoundStatement Bind(Binder &binder) override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	bool IsReadOnly() override {

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

@@ -28,6 +28,7 @@ public:
 public:
 	static unique_ptr<SelectStatement> ParseStatement(ClientContext &context, const string &query, const string &error);
 	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	unique_ptr<TableRef> GetTableRef() override;
 	BoundStatement Bind(Binder &binder) override;
 

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

@@ -29,6 +29,8 @@ public:
 
 public:
 	BoundStatement Bind(Binder &binder) override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	bool IsReadOnly() override {

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

@@ -23,6 +23,8 @@ public:
 
 public:
 	BoundStatement Bind(Binder &binder) override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	bool IsReadOnly() override {

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

@@ -24,6 +24,8 @@ public:
 
 public:
 	BoundStatement Bind(Binder &binder) override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+	string GetQuery() override;
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	bool IsReadOnly() override {

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

@@ -78,7 +78,8 @@ public:
 
 public:
 	DUCKDB_API virtual const vector<ColumnDefinition> &Columns() = 0;
-	DUCKDB_API virtual unique_ptr<QueryNode> GetQueryNode();
+	DUCKDB_API virtual unique_ptr<QueryNode> GetQueryNode() = 0;
+	DUCKDB_API virtual string GetQuery();
 	DUCKDB_API virtual BoundStatement Bind(Binder &binder);
 	DUCKDB_API virtual string GetAlias();
 

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

@@ -296,7 +296,9 @@ public:
 		Value result;
 		auto lookup_result = TryGetSecretKeyOrSetting(secret_key, setting_name, result);
 		if (lookup_result) {
-			value_out = result.GetValue<TYPE>();
+			if (!result.IsNull()) {
+				value_out = result.GetValue<TYPE>();
+			}
 		}
 		return lookup_result;
 	}

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

@@ -102,8 +102,9 @@ private:
 	void ExtractFilterBindings(const Expression &expr, vector<ColumnBinding> &bindings);
 	//! Generate filters from the current set of filters stored in the FilterCombiner
 	void GenerateFilters();
-	//! if there are filters in this FilterPushdown node, push them into the combiner
-	void PushFilters();
+	//! if there are filters in this FilterPushdown node, push them into the combiner. Returns
+	//! FilterResult::UNSATISFIABLE if the subtree should be stripped, or FilterResult::SUCCESS otherwise
+	FilterResult PushFilters();
 };
 
 } // namespace duckdb

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

@@ -100,6 +100,65 @@ struct CorrelatedColumnInfo {
 	}
 };
 
+struct CorrelatedColumns {
+private:
+	using container_type = vector<CorrelatedColumnInfo>;
+
+public:
+	CorrelatedColumns() : delim_index(1ULL << 63) {
+	}
+
+	void AddColumn(container_type::value_type info) {
+		// Add to beginning
+		correlated_columns.insert(correlated_columns.begin(), std::move(info));
+		delim_index++;
+	}
+
+	void SetDelimIndexToZero() {
+		delim_index = 0;
+	}
+
+	idx_t GetDelimIndex() const {
+		return delim_index;
+	}
+
+	const container_type::value_type &operator[](const idx_t &index) const {
+		return correlated_columns.at(index);
+	}
+
+	idx_t size() const { // NOLINT: match stl case
+		return correlated_columns.size();
+	}
+
+	bool empty() const { // NOLINT: match stl case
+		return correlated_columns.empty();
+	}
+
+	void clear() { // NOLINT: match stl case
+		correlated_columns.clear();
+	}
+
+	container_type::iterator begin() { // NOLINT: match stl case
+		return correlated_columns.begin();
+	}
+
+	container_type::iterator end() { // NOLINT: match stl case
+		return correlated_columns.end();
+	}
+
+	container_type::const_iterator begin() const { // NOLINT: match stl case
+		return correlated_columns.begin();
+	}
+
+	container_type::const_iterator end() const { // NOLINT: match stl case
+		return correlated_columns.end();
+	}
+
+private:
+	container_type correlated_columns;
+	idx_t delim_index;
+};
+
 //! Bind the parsed query tree to the actual columns present in the catalog.
 /*!
   The binder is responsible for binding tables and columns to actual physical
@@ -124,7 +183,7 @@ public:
 	BindContext bind_context;
 	//! The set of correlated columns bound by this binder (FIXME: this should probably be an unordered_set and not a
 	//! vector)
-	vector<CorrelatedColumnInfo> correlated_columns;
+	CorrelatedColumns correlated_columns;
 	//! The set of parameter expressions bound by this binder
 	optional_ptr<BoundParameterMap> parameters;
 	//! The alias for the currently processing subquery, if it exists
@@ -200,7 +259,7 @@ public:
 
 	vector<reference<ExpressionBinder>> &GetActiveBinders();
 
-	void MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other);
+	void MergeCorrelatedColumns(CorrelatedColumns &other);
 	//! Add a correlated column to this binder (if it does not exist)
 	void AddCorrelatedColumn(const CorrelatedColumnInfo &info);
 
@@ -428,7 +487,7 @@ private:
 	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,
+	                                            CorrelatedColumns &correlated_columns,
 	                                            JoinType join_type = JoinType::INNER,
 	                                            unique_ptr<Expression> condition = nullptr);
 

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

@@ -24,7 +24,7 @@ public:
 		return !correlated_columns.empty();
 	}
 
-	static void ReduceExpressionDepth(LogicalOperator &op, const vector<CorrelatedColumnInfo> &info);
+	static void ReduceExpressionDepth(LogicalOperator &op, const CorrelatedColumns &info);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
@@ -37,7 +37,7 @@ private:
 	void ExtractCorrelatedColumns(Expression &expr);
 
 private:
-	vector<CorrelatedColumnInfo> correlated_columns;
+	CorrelatedColumns correlated_columns;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_cte.hpp

@@ -35,6 +35,6 @@ public:
 	string ctename;
 	idx_t table_index;
 	idx_t column_count;
-	vector<CorrelatedColumnInfo> correlated_columns;
+	CorrelatedColumns correlated_columns;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_dependent_join.hpp

@@ -27,7 +27,7 @@ public:
 
 public:
 	explicit LogicalDependentJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-	                              vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+	                              CorrelatedColumns correlated_columns, JoinType type,
 	                              unique_ptr<Expression> condition);
 
 	explicit LogicalDependentJoin(JoinType type);
@@ -35,7 +35,7 @@ public:
 	//! The conditions of the join
 	unique_ptr<Expression> join_condition;
 	//! The list of columns that have correlations with the right
-	vector<CorrelatedColumnInfo> correlated_columns;
+	CorrelatedColumns correlated_columns;
 
 	SubqueryType subquery_type = SubqueryType::INVALID;
 	bool perform_delim = true;
@@ -51,7 +51,7 @@ public:
 
 public:
 	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-	                                          vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+	                                          CorrelatedColumns correlated_columns, JoinType type,
 	                                          unique_ptr<Expression> condition);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/subquery/flatten_dependent_join.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 //! The FlattenDependentJoins class is responsible for pushing the dependent join down into the plan to create a
 //! flattened subquery
 struct FlattenDependentJoins {
-	FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated, bool perform_delim = true,
+	FlattenDependentJoins(Binder &binder, const CorrelatedColumns &correlated, bool perform_delim = true,
 	                      bool any_join = false, optional_ptr<FlattenDependentJoins> parent = nullptr);
 
 	static unique_ptr<LogicalOperator> DecorrelateIndependent(Binder &binder, unique_ptr<LogicalOperator> plan);
@@ -47,7 +47,7 @@ public:
 	reference_map_t<LogicalOperator, bool> has_correlated_expressions;
 	column_binding_map_t<idx_t> correlated_map;
 	column_binding_map_t<idx_t> replacement_map;
-	const vector<CorrelatedColumnInfo> &correlated_columns;
+	const CorrelatedColumns &correlated_columns;
 	vector<LogicalType> delim_types;
 
 	bool perform_delim;

package/src/duckdb/src/include/duckdb/planner/subquery/has_correlated_expressions.hpp

@@ -16,7 +16,7 @@ namespace duckdb {
 //! Helper class to recursively detect correlated expressions inside a single LogicalOperator
 class HasCorrelatedExpressions : public LogicalOperatorVisitor {
 public:
-	explicit HasCorrelatedExpressions(const vector<CorrelatedColumnInfo> &correlated, bool lateral = false,
+	explicit HasCorrelatedExpressions(const CorrelatedColumns &correlated, bool lateral = false,
 	                                  idx_t lateral_depth = 0);
 
 	void VisitOperator(LogicalOperator &op) override;
@@ -28,7 +28,7 @@ protected:
 	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
 	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override;
 
-	const vector<CorrelatedColumnInfo> &correlated_columns;
+	const CorrelatedColumns &correlated_columns;
 	// Tracks number of nested laterals
 	idx_t lateral_depth;
 };

package/src/duckdb/src/include/duckdb/planner/subquery/rewrite_cte_scan.hpp

@@ -17,13 +17,13 @@ namespace duckdb {
 //! Helper class to rewrite correlated cte scans within a single LogicalOperator
 class RewriteCTEScan : public LogicalOperatorVisitor {
 public:
-	RewriteCTEScan(idx_t table_index, const vector<CorrelatedColumnInfo> &correlated_columns);
+	RewriteCTEScan(idx_t table_index, const CorrelatedColumns &correlated_columns);
 
 	void VisitOperator(LogicalOperator &op) override;
 
 private:
 	idx_t table_index;
-	const vector<CorrelatedColumnInfo> &correlated_columns;
+	const CorrelatedColumns &correlated_columns;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/tableref/bound_joinref.hpp

@@ -47,7 +47,7 @@ public:
 	//! Whether or not this is a lateral join
 	bool lateral;
 	//! The correlated columns of the right-side with the left-side
-	vector<CorrelatedColumnInfo> correlated_columns;
+	CorrelatedColumns correlated_columns;
 	//! The mark index, for mark joins generated by the relational API
 	idx_t mark_index {};
 };

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_analyze.hpp

@@ -82,7 +82,12 @@ unique_ptr<AnalyzeState> AlpInitAnalyze(ColumnData &col_data, PhysicalType type)
  */
 template <class T>
 bool AlpAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &analyze_state = (AlpAnalyzeState<T> &)state;
+	if (state.info.GetBlockSize() + state.info.GetBlockHeaderSize() < DEFAULT_BLOCK_ALLOC_SIZE) {
+		return false;
+	}
+
+	auto &analyze_state = state.Cast<AlpAnalyzeState<T>>();
+
 	bool must_skip_current_vector = alp::AlpUtils::MustSkipSamplingFromCurrentVector(
 	    analyze_state.vectors_count, analyze_state.vectors_sampled_count, count);
 	analyze_state.vectors_count += 1;

package/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_analyze.hpp

@@ -47,8 +47,12 @@ unique_ptr<AnalyzeState> AlpRDInitAnalyze(ColumnData &col_data, PhysicalType typ
  */
 template <class T>
 bool AlpRDAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
+	if (state.info.GetBlockSize() + state.info.GetBlockHeaderSize() < DEFAULT_BLOCK_ALLOC_SIZE) {
+		return false;
+	}
+
 	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
-	auto &analyze_state = (AlpRDAnalyzeState<T> &)state;
+	auto &analyze_state = state.Cast<AlpRDAnalyzeState<T>>();
 
 	bool must_skip_current_vector = alp::AlpUtils::MustSkipSamplingFromCurrentVector(
 	    analyze_state.vectors_count, analyze_state.vectors_sampled_count, count);

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_manager.hpp

@@ -92,17 +92,19 @@ public:
 protected:
 	BlockManager &block_manager;
 	BufferManager &buffer_manager;
+	mutable mutex block_lock;
 	unordered_map<block_id_t, MetadataBlock> blocks;
 	unordered_map<block_id_t, idx_t> modified_blocks;
 
 protected:
-	block_id_t AllocateNewBlock();
-	block_id_t PeekNextBlockId();
-	block_id_t GetNextBlockId();
-
-	void AddBlock(MetadataBlock new_block, bool if_exists = false);
-	void AddAndRegisterBlock(MetadataBlock block);
-	void ConvertToTransient(MetadataBlock &block);
+	block_id_t AllocateNewBlock(unique_lock<mutex> &block_lock);
+	block_id_t PeekNextBlockId() const;
+	block_id_t GetNextBlockId() const;
+
+	void AddBlock(unique_lock<mutex> &block_lock, MetadataBlock new_block, bool if_exists = false);
+	void AddAndRegisterBlock(unique_lock<mutex> &block_lock, MetadataBlock block);
+	void ConvertToTransient(unique_lock<mutex> &block_lock, MetadataBlock &block);
+	MetadataPointer FromDiskPointerInternal(unique_lock<mutex> &block_lock, MetaBlockPointer pointer);
 };
 
 } // namespace duckdb