duckdb 1.4.3-dev0.0 → 1.4.4-dev0.0

package/src/duckdb/src/include/duckdb/execution/index/unbound_index.hpp

@@ -18,11 +18,43 @@ class ColumnDataCollection;
 
 enum class BufferedIndexReplay : uint8_t { INSERT_ENTRY = 0, DEL_ENTRY = 1 };
 
-struct BufferedIndexData {
+struct ReplayRange {
 	BufferedIndexReplay type;
-	unique_ptr<ColumnDataCollection> data;
+	// [start, end) - start is inclusive, end is exclusive for the range within the ColumnDataCollection
+	// buffer for operations to replay for this range.
+	idx_t start;
+	idx_t end;
+	explicit ReplayRange(const BufferedIndexReplay replay_type, const idx_t start_p, const idx_t end_p)
+	    : type(replay_type), start(start_p), end(end_p) {
+	}
+};
+
+// All inserts and deletes to be replayed are stored in their respective buffers.
+// Since the inserts and deletes may be interleaved, however, ranges stores the ordering of operations
+// and their offsets in the respective buffer.
+// Simple example:
+// ranges[0] - INSERT_ENTRY, [0,6)
+// ranges[1] - DEL_ENTRY,    [0,3)
+// ranges[2] - INSERT_ENTRY  [6,12)
+// So even though the buffered_inserts has all the insert data from [0,12), ranges gives us the intervals for
+// replaying the index operations in the right order.
+struct BufferedIndexReplays {
+	vector<ReplayRange> ranges;
+	unique_ptr<ColumnDataCollection> buffered_inserts;
+	unique_ptr<ColumnDataCollection> buffered_deletes;
+
+	BufferedIndexReplays() = default;
+
+	unique_ptr<ColumnDataCollection> &GetBuffer(const BufferedIndexReplay replay_type) {
+		if (replay_type == BufferedIndexReplay::INSERT_ENTRY) {
+			return buffered_inserts;
+		}
+		return buffered_deletes;
+	}
 
-	BufferedIndexData(BufferedIndexReplay replay_type, unique_ptr<ColumnDataCollection> data_p);
+	bool HasBufferedReplays() const {
+		return !ranges.empty();
+	}
 };
 
 class UnboundIndex final : public Index {
@@ -31,8 +63,9 @@ private:
 	unique_ptr<CreateInfo> create_info;
 	//! The serialized storage information of the index.
 	IndexStorageInfo storage_info;
-	//! Buffer for WAL replays.
-	vector<BufferedIndexData> buffered_replays;
+
+	//! Buffered for index operations during WAL replay. They are replayed upon index binding.
+	BufferedIndexReplays buffered_replays;
 
 	//! Maps the column IDs in the buffered replays to a physical table offset.
 	//! For example, column [i] in a buffered ColumnDataCollection is the data for an Indexed column with
@@ -78,12 +111,13 @@ public:
 	void BufferChunk(DataChunk &index_column_chunk, Vector &row_ids, const vector<StorageIndex> &mapped_column_ids_p,
 	                 BufferedIndexReplay replay_type);
 	bool HasBufferedReplays() const {
-		return !buffered_replays.empty();
+		return buffered_replays.HasBufferedReplays();
 	}
 
-	vector<BufferedIndexData> &GetBufferedReplays() {
+	BufferedIndexReplays &GetBufferedReplays() {
 		return buffered_replays;
 	}
+
 	const vector<StorageIndex> &GetMappedColumnIds() const {
 		return mapped_column_ids;
 	}

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp

@@ -121,6 +121,8 @@ public:
 
 	virtual ~BaseScanner() = default;
 
+	void Print() const;
+
 	//! Returns true if the scanner is finished
 	bool FinishedFile() const;
 
@@ -164,10 +166,15 @@ public:
 	//! States
 	CSVStates states;
 
+	//! If the scanner ever entered a quoted state
 	bool ever_quoted = false;
 
+	//! If the scanner ever entered an escaped state.
 	bool ever_escaped = false;
 
+	//! If the scanner ever used advantage of the non-strict mode.
+	bool used_unstrictness = false;
+
 	//! Shared pointer to the buffer_manager, this is shared across multiple scanners
 	shared_ptr<CSVBufferManager> buffer_manager;
 
@@ -302,6 +309,9 @@ protected:
 				     !state_machine->dialect_options.state_machine_options.strict_mode.GetValue())) {
 					// We only set the ever escaped variable if this is either a quote char OR strict mode is off
 					ever_escaped = true;
+					if (states.states[0] == CSVState::UNQUOTED_ESCAPE) {
+						used_unstrictness = true;
+					}
 				}
 				ever_quoted = true;
 				T::SetQuoted(result, iterator.pos.buffer_pos);
@@ -332,11 +342,15 @@ protected:
 				break;
 			}
 			case CSVState::ESCAPE:
-			case CSVState::UNQUOTED_ESCAPE:
 			case CSVState::ESCAPED_RETURN:
 				T::SetEscaped(result);
 				iterator.pos.buffer_pos++;
 				break;
+			case CSVState::UNQUOTED_ESCAPE:
+				T::SetEscaped(result);
+				iterator.pos.buffer_pos++;
+				used_unstrictness = true;
+				break;
 			case CSVState::STANDARD: {
 				iterator.pos.buffer_pos++;
 				while (iterator.pos.buffer_pos + 8 < to_pos) {

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp

@@ -116,6 +116,7 @@ private:
 	//! Highest number of columns found
 	idx_t max_columns_found = 0;
 	idx_t max_columns_found_error = 0;
+	bool best_candidate_is_strict = false;
 	//! Current Candidates being considered
 	vector<unique_ptr<ColumnCountScanner>> candidates;
 	//! Reference to original CSV Options, it will be modified as a result of the sniffer.

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp

@@ -176,7 +176,7 @@ public:
 	                  const shared_ptr<CSVBufferHandle> &buffer_handle, Allocator &buffer_allocator,
 	                  idx_t result_size_p, idx_t buffer_position, CSVErrorHandler &error_handler, CSVIterator &iterator,
 	                  bool store_line_size, shared_ptr<CSVFileScan> csv_file_scan, idx_t &lines_read, bool sniffing,
-	                  string path, idx_t scan_id);
+	                  const string &path, idx_t scan_id, bool &used_unstrictness);
 
 	~StringValueResult();
 
@@ -225,6 +225,7 @@ public:
 
 	shared_ptr<CSVFileScan> csv_file_scan;
 	idx_t &lines_read;
+	bool &used_unstrictness;
 	//! Information regarding projected columns
 	unsafe_unique_array<bool> projected_columns;
 	bool projecting_columns = false;

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parser/group_by_node.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/logical_tokens.hpp"
 #include "duckdb/planner/joinside.hpp"
@@ -152,7 +153,8 @@ protected:
 	PhysicalOperator &PlanComparisonJoin(LogicalComparisonJoin &op);
 	PhysicalOperator &PlanDelimJoin(LogicalComparisonJoin &op);
 	PhysicalOperator &ExtractAggregateExpressions(PhysicalOperator &child, vector<unique_ptr<Expression>> &expressions,
-	                                              vector<unique_ptr<Expression>> &groups);
+	                                              vector<unique_ptr<Expression>> &groups,
+	                                              optional_ptr<vector<GroupingSet>> grouping_sets);
 
 private:
 	ClientContext &context;

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

@@ -70,7 +70,8 @@ public:
 	                      AggregateType aggr_type = AggregateType::NON_DISTINCT);
 
 	DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
-	                                           const vector<unique_ptr<Expression>> &groups);
+	                                           const vector<unique_ptr<Expression>> &groups,
+	                                           optional_ptr<vector<GroupingSet>> grouping_sets);
 	DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundWindowExpression &expr);
 
 	//! Cast a set of expressions to the arguments of this function

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

@@ -432,6 +432,8 @@ public:
 	TableFunctionInitialization global_initialization = TableFunctionInitialization::INITIALIZE_ON_EXECUTE;
 
 	DUCKDB_API bool Equal(const TableFunction &rhs) const;
+	DUCKDB_API bool operator==(const TableFunction &rhs) const;
+	DUCKDB_API bool operator!=(const TableFunction &rhs) const;
 };
 
 } // namespace duckdb

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

@@ -26,6 +26,8 @@ struct DatabaseCacheEntry {
 	mutex update_database_mutex;
 };
 
+enum class CacheBehavior { AUTOMATIC, ALWAYS_CACHE, NEVER_CACHE };
+
 class DBInstanceCache {
 public:
 	DBInstanceCache();
@@ -41,6 +43,9 @@ public:
 	//! Either returns an existing entry, or creates and caches a new DB Instance
 	shared_ptr<DuckDB> GetOrCreateInstance(const string &database, DBConfig &config_dict, bool cache_instance,
 	                                       const std::function<void(DuckDB &)> &on_create = nullptr);
+	shared_ptr<DuckDB> GetOrCreateInstance(const string &database, DBConfig &config_dict,
+	                                       CacheBehavior cache_behavior = CacheBehavior::AUTOMATIC,
+	                                       const std::function<void(DuckDB &)> &on_create = nullptr);
 
 private:
 	shared_ptr<DatabaseFilePathManager> path_manager;

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

@@ -1045,6 +1045,8 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"http_retry_wait_ms", "httpfs"},
     {"http_timeout", "httpfs"},
     {"httpfs_client_implementation", "httpfs"},
+    {"iceberg_via_aws_sdk_for_catalog_interactions", "iceberg"},
+    {"merge_http_secret_into_s3_request", "httpfs"},
     {"mysql_bit1_as_boolean", "mysql_scanner"},
     {"mysql_debug_show_queries", "mysql_scanner"},
     {"mysql_experimental_filter_pushdown", "mysql_scanner"},

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

@@ -50,6 +50,7 @@ public:
 	//! If this returns true - this sorts "in_list" as a side-effect
 	static bool IsDenseRange(vector<Value> &in_list);
 	static bool ContainsNull(vector<Value> &in_list);
+	static bool FindNextLegalUTF8(string &prefix_string);
 
 	void GenerateFilters(const std::function<void(unique_ptr<Expression> filter)> &callback);
 	bool HasFilters();

package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp

@@ -57,10 +57,10 @@ public:
 	bool ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings);
 	void AddRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent, const RelationStats &stats);
 	//! Add an unnest relation which can come from a logical unnest or a logical get which has an unnest function
-	void AddUnnestRelation(JoinOrderOptimizer &optimizer, LogicalOperator &op, LogicalOperator &input_op,
-	                       optional_ptr<LogicalOperator> parent, RelationStats &child_stats,
-	                       optional_ptr<LogicalOperator> limit_op,
-	                       vector<reference<LogicalOperator>> &datasource_filters);
+	void AddRelationWithChildren(JoinOrderOptimizer &optimizer, LogicalOperator &op, LogicalOperator &input_op,
+	                             optional_ptr<LogicalOperator> parent, RelationStats &child_stats,
+	                             optional_ptr<LogicalOperator> limit_op,
+	                             vector<reference<LogicalOperator>> &datasource_filters);
 	void AddAggregateOrWindowRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent,
 	                                  const RelationStats &stats, LogicalOperatorType op_type);
 	vector<unique_ptr<SingleJoinRelation>> GetRelations();

package/src/duckdb/src/include/duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/optimizer/rule.hpp"
 #include "duckdb/parser/expression_map.hpp"
+#include "duckdb/parser/group_by_node.hpp"
 
 namespace duckdb {
 
@@ -18,7 +19,8 @@ public:
 	explicit OrderedAggregateOptimizer(ExpressionRewriter &rewriter);
 
 	static unique_ptr<Expression> Apply(ClientContext &context, BoundAggregateExpression &aggr,
-	                                    vector<unique_ptr<Expression>> &groups, bool &changes_made);
+	                                    vector<unique_ptr<Expression>> &groups,
+	                                    optional_ptr<vector<GroupingSet>> grouping_sets, bool &changes_made);
 	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };

package/src/duckdb/src/include/duckdb/parser/parsed_data/sample_options.hpp

@@ -23,6 +23,9 @@ enum class SampleMethod : uint8_t { SYSTEM_SAMPLE = 0, BERNOULLI_SAMPLE = 1, RES
 string SampleMethodToString(SampleMethod method);
 
 class SampleOptions {
+public:
+	// 1 billion rows should be enough.
+	static constexpr idx_t MAX_SAMPLE_ROWS = 1000000000;
 
 public:
 	explicit SampleOptions(int64_t seed_ = -1);

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

@@ -405,7 +405,7 @@ private:
 
 	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func, idx_t depth);
 
-	unique_ptr<BoundCTENode> BindMaterializedCTE(CommonTableExpressionMap &cte_map);
+	unique_ptr<BoundCTENode> BindMaterializedCTE(CommonTableExpressionMap &cte_map, unique_ptr<CTENode> &cte_root);
 	unique_ptr<BoundCTENode> BindCTE(CTENode &statement);
 
 	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/limits.hpp"
+#include "duckdb/parser/group_by_node.hpp"
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/planner/bound_statement.hpp"
 #include "duckdb/planner/expression.hpp"
@@ -155,8 +156,9 @@ public:
 
 	//! Remove unneeded/duplicate order elements.
 	//! Returns true of orders is not empty.
-	static bool Simplify(vector<BoundOrderByNode> &orders, const vector<unique_ptr<Expression>> &groups);
-	bool Simplify(const vector<unique_ptr<Expression>> &groups);
+	static bool Simplify(vector<BoundOrderByNode> &orders, const vector<unique_ptr<Expression>> &groups,
+	                     optional_ptr<vector<GroupingSet>> grouping_sets);
+	bool Simplify(const vector<unique_ptr<Expression>> &groups, optional_ptr<vector<GroupingSet>> grouping_sets);
 };
 
 enum class DistinctType : uint8_t { DISTINCT = 0, DISTINCT_ON = 1 };

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

@@ -10,9 +10,8 @@
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/stack_checker.hpp"
-#include "duckdb/common/exception/binder_exception.hpp"
 #include "duckdb/common/error_data.hpp"
-#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/exception/binder_exception.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/parser/expression/lambdaref_expression.hpp"
 #include "duckdb/parser/parsed_expression.hpp"

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

@@ -33,7 +33,7 @@ private:
 	                                 bool parent_is_dependent_join = false);
 
 	//! Mark entire subtree of Logical Operators as correlated by adding them to the has_correlated_expressions map.
-	bool MarkSubtreeCorrelated(LogicalOperator &op);
+	bool MarkSubtreeCorrelated(LogicalOperator &op, idx_t cte_index);
 
 	//! Push the dependent join down a LogicalOperator
 	unique_ptr<LogicalOperator> PushDownDependentJoin(unique_ptr<LogicalOperator> plan,

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

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

package/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp

@@ -45,7 +45,7 @@ public:
 	virtual bool Fetch(TransactionData transaction, row_t row) = 0;
 	virtual void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) = 0;
 	virtual idx_t GetCommittedDeletedCount(idx_t max_count) = 0;
-	virtual bool Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const;
+	virtual bool Cleanup(transaction_t lowest_transaction) const;
 
 	virtual bool HasDeletes() const = 0;
 
@@ -87,7 +87,7 @@ public:
 	bool Fetch(TransactionData transaction, row_t row) override;
 	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
 	idx_t GetCommittedDeletedCount(idx_t max_count) override;
-	bool Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const override;
+	bool Cleanup(transaction_t lowest_transaction) const override;
 
 	bool HasDeletes() const override;
 
@@ -124,7 +124,7 @@ public:
 	                            SelectionVector &sel_vector, idx_t max_count) override;
 	bool Fetch(TransactionData transaction, row_t row) override;
 	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
-	bool Cleanup(transaction_t lowest_transaction, unique_ptr<ChunkInfo> &result) const override;
+	bool Cleanup(transaction_t lowest_transaction) const override;
 	idx_t GetCommittedDeletedCount(idx_t max_count) override;
 
 	void Append(idx_t start, idx_t end, transaction_t commit_id);

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -99,10 +99,6 @@ public:
 
 	const vector<MetaBlockPointer> &GetColumnStartPointers() const;
 
-	//! Returns the list of meta block pointers used by the deletes
-	const vector<MetaBlockPointer> &GetDeletesPointers() const {
-		return deletes_pointers;
-	}
 	BlockManager &GetBlockManager();
 	DataTableInfo &GetTableInfo();
 
@@ -198,6 +194,8 @@ public:
 
 	static FilterPropagateResult CheckRowIdFilter(const TableFilter &filter, idx_t beg_row, idx_t end_row);
 
+	vector<MetaBlockPointer> CheckpointDeletes(MetadataManager &manager);
+
 private:
 	optional_ptr<RowVersionManager> GetVersionInfo();
 	shared_ptr<RowVersionManager> GetOrCreateVersionInfoPtr();
@@ -214,8 +212,6 @@ private:
 	template <TableScanType TYPE>
 	void TemplatedScan(TransactionData transaction, CollectionScanState &state, DataChunk &result);
 
-	vector<MetaBlockPointer> CheckpointDeletes(MetadataManager &manager);
-
 	bool HasUnloadedDeletes() const;
 
 private:

package/src/duckdb/src/include/duckdb/storage/table/row_version_manager.hpp

@@ -46,11 +46,14 @@ public:
 	static shared_ptr<RowVersionManager> Deserialize(MetaBlockPointer delete_pointer, MetadataManager &manager,
 	                                                 idx_t start);
 
+	bool HasUnserializedChanges();
+	vector<MetaBlockPointer> GetStoragePointers();
+
 private:
 	mutex version_lock;
 	idx_t start;
 	vector<unique_ptr<ChunkInfo>> vector_info;
-	bool has_changes;
+	bool has_unserialized_changes;
 	vector<MetaBlockPointer> storage_pointers;
 
 private:

package/src/duckdb/src/include/duckdb/storage/table/validity_column_data.hpp

@@ -23,6 +23,8 @@ public:
 public:
 	FilterPropagateResult CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
 	void AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) override;
+	void UpdateWithBase(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+	                    row_t *row_ids, idx_t update_count, ColumnData &base);
 };
 
 } // namespace duckdb

package/src/duckdb/src/logging/log_storage.cpp

@@ -22,26 +22,19 @@ namespace duckdb {
 
 vector<LogicalType> LogStorage::GetSchema(LoggingTargetTable table) {
 	switch (table) {
-	case LoggingTargetTable::ALL_LOGS:
-		return {
-		    LogicalType::UBIGINT,   // context_id
-		    LogicalType::VARCHAR,   // scope
-		    LogicalType::UBIGINT,   // connection_id
-		    LogicalType::UBIGINT,   // transaction_id
-		    LogicalType::UBIGINT,   // query_id
-		    LogicalType::UBIGINT,   // thread
-		    LogicalType::TIMESTAMP, // timestamp
-		    LogicalType::VARCHAR,   // log_type
-		    LogicalType::VARCHAR,   // level
-		    LogicalType::VARCHAR,   // message
-		};
+	case LoggingTargetTable::ALL_LOGS: {
+		auto all_logs = GetSchema(LoggingTargetTable::LOG_CONTEXTS);
+		auto log_entries = GetSchema(LoggingTargetTable::LOG_ENTRIES);
+		all_logs.insert(all_logs.end(), log_entries.begin() + 1, log_entries.end());
+		return all_logs;
+	}
 	case LoggingTargetTable::LOG_ENTRIES:
 		return {
-		    LogicalType::UBIGINT,   // context_id
-		    LogicalType::TIMESTAMP, // timestamp
-		    LogicalType::VARCHAR,   // log_type
-		    LogicalType::VARCHAR,   // level
-		    LogicalType::VARCHAR,   // message
+		    LogicalType::UBIGINT,      // context_id
+		    LogicalType::TIMESTAMP_TZ, // timestamp
+		    LogicalType::VARCHAR,      // log_type
+		    LogicalType::VARCHAR,      // level
+		    LogicalType::VARCHAR,      // message
 		};
 	case LoggingTargetTable::LOG_CONTEXTS:
 		return {
@@ -59,11 +52,12 @@ vector<LogicalType> LogStorage::GetSchema(LoggingTargetTable table) {
 
 vector<string> LogStorage::GetColumnNames(LoggingTargetTable table) {
 	switch (table) {
-	case LoggingTargetTable::ALL_LOGS:
-		return {
-		    "context_id", "scope",     "connection_id", "transaction_id", "query_id",
-		    "thread_id",  "timestamp", "type",          "log_level",      "message",
-		};
+	case LoggingTargetTable::ALL_LOGS: {
+		auto all_logs = GetColumnNames(LoggingTargetTable::LOG_CONTEXTS);
+		auto log_entries = GetColumnNames(LoggingTargetTable::LOG_ENTRIES);
+		all_logs.insert(all_logs.end(), log_entries.begin() + 1, log_entries.end());
+		return all_logs;
+	}
 	case LoggingTargetTable::LOG_ENTRIES:
 		return {"context_id", "timestamp", "type", "log_level", "message"};
 	case LoggingTargetTable::LOG_CONTEXTS:

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

@@ -41,7 +41,7 @@ duckdb_state duckdb_open_internal(DBInstanceCacheWrapper *cache, const char *pat
 			if (path) {
 				path_str = path;
 			}
-			wrapper->database = cache->instance_cache->GetOrCreateInstance(path_str, *db_config, true);
+			wrapper->database = cache->instance_cache->GetOrCreateInstance(path_str, *db_config);
 		} else {
 			wrapper->database = duckdb::make_shared_ptr<DuckDB>(path, db_config);
 		}

package/src/duckdb/src/main/connection.cpp

@@ -23,11 +23,6 @@ Connection::Connection(DatabaseInstance &database)
 	auto &connection_manager = ConnectionManager::Get(database);
 	connection_manager.AddConnection(*context);
 	connection_manager.AssignConnectionId(*this);
-
-#ifdef DEBUG
-	EnableProfiling();
-	context->config.emit_profiler_output = false;
-#endif
 }
 
 Connection::Connection(DuckDB &database) : Connection(*database.instance) {

package/src/duckdb/src/main/database_manager.cpp

@@ -83,7 +83,16 @@ shared_ptr<AttachedDatabase> DatabaseManager::GetDatabaseInternal(const lock_gua
 
 shared_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &context, AttachInfo &info,
                                                              AttachOptions &options) {
-	auto &config = DBConfig::GetConfig(context);
+	string extension = "";
+	if (FileSystem::IsRemoteFile(info.path, extension)) {
+		if (options.access_mode == AccessMode::AUTOMATIC) {
+			// Attaching of remote files gets bumped to READ_ONLY
+			// This is due to the fact that on most (all?) remote files writes to DB are not available
+			// and having this raised later is not super helpful
+			options.access_mode = AccessMode::READ_ONLY;
+		}
+	}
+
 	if (options.db_type.empty() || StringUtil::CIEquals(options.db_type, "duckdb")) {
 		while (InsertDatabasePath(info, options) == InsertDatabasePathResult::ALREADY_EXISTS) {
 			// database with this name and path already exists
@@ -99,6 +108,7 @@ shared_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &cont
 			}
 		}
 	}
+	auto &config = DBConfig::GetConfig(context);
 	GetDatabaseType(context, info, config, options);
 	if (!options.db_type.empty()) {
 		// we only need to prevent duplicate opening of DuckDB files
@@ -108,18 +118,11 @@ shared_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &cont
 	if (AttachedDatabase::NameIsReserved(info.name)) {
 		throw BinderException("Attached database name \"%s\" cannot be used because it is a reserved name", info.name);
 	}
-	string extension = "";
-	if (FileSystem::IsRemoteFile(info.path, extension)) {
+	if (!extension.empty()) {
 		if (!ExtensionHelper::TryAutoLoadExtension(context, extension)) {
 			throw MissingExtensionException("Attaching path '%s' requires extension '%s' to be loaded", info.path,
 			                                extension);
 		}
-		if (options.access_mode == AccessMode::AUTOMATIC) {
-			// Attaching of remote files gets bumped to READ_ONLY
-			// This is due to the fact that on most (all?) remote files writes to DB are not available
-			// and having this raised later is not super helpful
-			options.access_mode = AccessMode::READ_ONLY;
-		}
 	}
 
 	// now create the attached database

package/src/duckdb/src/main/db_instance_cache.cpp

@@ -137,9 +137,23 @@ shared_ptr<DuckDB> DBInstanceCache::CreateInstance(const string &database, DBCon
 shared_ptr<DuckDB> DBInstanceCache::GetOrCreateInstance(const string &database, DBConfig &config_dict,
                                                         bool cache_instance,
                                                         const std::function<void(DuckDB &)> &on_create) {
+	auto cache_behavior = cache_instance ? CacheBehavior::ALWAYS_CACHE : CacheBehavior::NEVER_CACHE;
+	return GetOrCreateInstance(database, config_dict, cache_behavior, on_create);
+}
+
+shared_ptr<DuckDB> DBInstanceCache::GetOrCreateInstance(const string &database, DBConfig &config_dict,
+                                                        CacheBehavior cache_behavior,
+                                                        const std::function<void(DuckDB &)> &on_create) {
 	unique_lock<mutex> lock(cache_lock, std::defer_lock);
+	bool cache_instance = cache_behavior == CacheBehavior::ALWAYS_CACHE;
+	if (cache_behavior == CacheBehavior::AUTOMATIC) {
+		// cache all unnamed in-memory connections
+		cache_instance = true;
+		if (database == IN_MEMORY_PATH || database.empty()) {
+			cache_instance = false;
+		}
+	}
 	if (cache_instance) {
-
 		// While we do not own the lock, we cannot definitively say that the database instance does not exist.
 		while (!lock.owns_lock()) {
 			// The problem is, that we have to unlock the mutex in GetInstanceInternal, so we can non-blockingly wait

package/src/duckdb/src/main/extension/extension_alias.cpp

@@ -10,6 +10,7 @@ static const ExtensionAlias internal_aliases[] = {{"http", "httpfs"}, // httpfs
                                                   {"postgres", "postgres_scanner"}, // postgres
                                                   {"sqlite", "sqlite_scanner"},     // sqlite
                                                   {"sqlite3", "sqlite_scanner"},
+                                                  {"uc_catalog", "unity_catalog"}, // old name for compatibility
                                                   {nullptr, nullptr}};
 
 idx_t ExtensionHelper::ExtensionAliasCount() {