duckdb 1.2.1-dev6.0 → 1.2.1-dev8.0

package/package.json

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

package/src/duckdb/extension/core_functions/aggregate/distributive/string_agg.cpp

@@ -44,14 +44,7 @@ struct StringAggFunction {
 		if (!state.dataptr) {
 			finalize_data.ReturnNull();
 		} else {
-			target = StringVector::AddString(finalize_data.result, state.dataptr, state.size);
-		}
-	}
-
-	template <class STATE>
-	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		if (state.dataptr) {
-			delete[] state.dataptr;
+			target = string_t(state.dataptr, state.size);
 		}
 	}
 
@@ -59,12 +52,12 @@ struct StringAggFunction {
 		return true;
 	}
 
-	static inline void PerformOperation(StringAggState &state, const char *str, const char *sep, idx_t str_size,
-	                                    idx_t sep_size) {
+	static inline void PerformOperation(StringAggState &state, ArenaAllocator &allocator, const char *str,
+	                                    const char *sep, idx_t str_size, idx_t sep_size) {
 		if (!state.dataptr) {
 			// first iteration: allocate space for the string and copy it into the state
 			state.alloc_size = MaxValue<idx_t>(8, NextPowerOfTwo(str_size));
-			state.dataptr = new char[state.alloc_size];
+			state.dataptr = char_ptr_cast(allocator.Allocate(state.alloc_size));
 			state.size = str_size;
 			memcpy(state.dataptr, str, str_size);
 		} else {
@@ -72,13 +65,12 @@ struct StringAggFunction {
 			idx_t required_size = state.size + str_size + sep_size;
 			if (required_size > state.alloc_size) {
 				// no space! allocate extra space
+				const auto old_size = state.alloc_size;
 				while (state.alloc_size < required_size) {
 					state.alloc_size *= 2;
 				}
-				auto new_data = new char[state.alloc_size];
-				memcpy(new_data, state.dataptr, state.size);
-				delete[] state.dataptr;
-				state.dataptr = new_data;
+				state.dataptr =
+				    char_ptr_cast(allocator.Reallocate(data_ptr_cast(state.dataptr), old_size, state.alloc_size));
 			}
 			// copy the separator
 			memcpy(state.dataptr + state.size, sep, sep_size);
@@ -89,14 +81,15 @@ struct StringAggFunction {
 		}
 	}
 
-	static inline void PerformOperation(StringAggState &state, string_t str, optional_ptr<FunctionData> data_p) {
+	static inline void PerformOperation(StringAggState &state, ArenaAllocator &allocator, string_t str,
+	                                    optional_ptr<FunctionData> data_p) {
 		auto &data = data_p->Cast<StringAggBindData>();
-		PerformOperation(state, str.GetData(), data.sep.c_str(), str.GetSize(), data.sep.size());
+		PerformOperation(state, allocator, str.GetData(), data.sep.c_str(), str.GetSize(), data.sep.size());
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
-		PerformOperation(state, input, unary_input.input.bind_data);
+		PerformOperation(state, unary_input.input.allocator, input, unary_input.input.bind_data);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
@@ -113,8 +106,8 @@ struct StringAggFunction {
 			// source is not set: skip combining
 			return;
 		}
-		PerformOperation(target, string_t(source.dataptr, UnsafeNumericCast<uint32_t>(source.size)),
-		                 aggr_input_data.bind_data);
+		PerformOperation(target, aggr_input_data.allocator,
+		                 string_t(source.dataptr, UnsafeNumericCast<uint32_t>(source.size)), aggr_input_data.bind_data);
 	}
 };
 
@@ -162,8 +155,7 @@ AggregateFunctionSet StringAggFun::GetFunctions() {
 	    AggregateFunction::UnaryScatterUpdate<StringAggState, string_t, StringAggFunction>,
 	    AggregateFunction::StateCombine<StringAggState, StringAggFunction>,
 	    AggregateFunction::StateFinalize<StringAggState, string_t, StringAggFunction>,
-	    AggregateFunction::UnaryUpdate<StringAggState, string_t, StringAggFunction>, StringAggBind,
-	    AggregateFunction::StateDestroy<StringAggState, StringAggFunction>);
+	    AggregateFunction::UnaryUpdate<StringAggState, string_t, StringAggFunction>, StringAggBind);
 	string_agg_param.serialize = StringAggSerialize;
 	string_agg_param.deserialize = StringAggDeserialize;
 	string_agg.AddFunction(string_agg_param);

package/src/duckdb/extension/core_functions/aggregate/nested/list.cpp

@@ -116,7 +116,6 @@ static void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_d
 
 	// first iterate over all entries and set up the list entries, and get the newly required total length
 	for (idx_t i = 0; i < count; i++) {
-
 		auto &state = *states[states_data.sel->get_index(i)];
 		const auto rid = i + offset;
 		result_data[rid].offset = total_len;

package/src/duckdb/extension/core_functions/lambda_functions.cpp

@@ -223,17 +223,6 @@ void ExecuteExpression(const idx_t elem_cnt, const LambdaFunctions::ColumnInfo &
 // ListLambdaBindData
 //===--------------------------------------------------------------------===//
 
-unique_ptr<FunctionData> ListLambdaBindData::Copy() const {
-	auto lambda_expr_copy = lambda_expr ? lambda_expr->Copy() : nullptr;
-	return make_uniq<ListLambdaBindData>(return_type, std::move(lambda_expr_copy), has_index);
-}
-
-bool ListLambdaBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<ListLambdaBindData>();
-	return Expression::Equals(lambda_expr, other.lambda_expr) && return_type == other.return_type &&
-	       has_index == other.has_index;
-}
-
 void ListLambdaBindData::Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                    const ScalarFunction &) {
 	auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();

package/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp

@@ -15,7 +15,17 @@
 
 namespace duckdb {
 
-// FIXME: use a local state for each thread to increase performance?
+struct ListAggregatesLocalState : public FunctionLocalState {
+	explicit ListAggregatesLocalState(Allocator &allocator) : arena_allocator(allocator) {
+	}
+
+	ArenaAllocator arena_allocator;
+};
+
+unique_ptr<FunctionLocalState> ListAggregatesInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
+                                                            FunctionData *bind_data) {
+	return make_uniq<ListAggregatesLocalState>(BufferAllocator::Get(state.GetContext()));
+}
 // FIXME: benchmark the use of simple_update against using update (if applicable)
 
 static unique_ptr<FunctionData> ListAggregatesBindFailure(ScalarFunction &bound_function) {
@@ -207,7 +217,8 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<ListAggregatesBindData>();
 	auto &aggr = info.aggr_expr->Cast<BoundAggregateExpression>();
-	ArenaAllocator allocator(Allocator::DefaultAllocator());
+	auto &allocator = ExecuteFunctionState::GetFunctionState(state)->Cast<ListAggregatesLocalState>().arena_allocator;
+	allocator.Reset();
 	AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
 
 	D_ASSERT(aggr.function.update);
@@ -511,8 +522,9 @@ static unique_ptr<FunctionData> ListUniqueBind(ClientContext &context, ScalarFun
 }
 
 ScalarFunction ListAggregateFun::GetFunction() {
-	auto result = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY,
-	                             ListAggregateFunction, ListAggregateBind);
+	auto result =
+	    ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY,
+	                   ListAggregateFunction, ListAggregateBind, nullptr, nullptr, ListAggregatesInitLocalState);
 	BaseScalarFunction::SetReturnsError(result);
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	result.varargs = LogicalType::ANY;
@@ -523,12 +535,12 @@ ScalarFunction ListAggregateFun::GetFunction() {
 
 ScalarFunction ListDistinctFun::GetFunction() {
 	return ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),
-	                      ListDistinctFunction, ListDistinctBind);
+	                      ListDistinctFunction, ListDistinctBind, nullptr, nullptr, ListAggregatesInitLocalState);
 }
 
 ScalarFunction ListUniqueFun::GetFunction() {
 	return ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::UBIGINT, ListUniqueFunction,
-	                      ListUniqueBind);
+	                      ListUniqueBind, nullptr, nullptr, ListAggregatesInitLocalState);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-datefunc.cpp

@@ -71,13 +71,20 @@ unique_ptr<FunctionData> ICUDateFunc::Bind(ClientContext &context, ScalarFunctio
 	return make_uniq<BindData>(context);
 }
 
-void ICUDateFunc::SetTimeZone(icu::Calendar *calendar, const string_t &tz_id) {
+bool ICUDateFunc::TrySetTimeZone(icu::Calendar *calendar, const string_t &tz_id) {
 	auto tz = icu_66::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(icu::StringPiece(tz_id.GetString())));
 	if (*tz == icu::TimeZone::getUnknown()) {
 		delete tz;
-		throw NotImplementedException("Unknown TimeZone '%s'", tz_id.GetString());
+		return false;
 	}
 	calendar->adoptTimeZone(tz);
+	return true;
+}
+
+void ICUDateFunc::SetTimeZone(icu::Calendar *calendar, const string_t &tz_id) {
+	if (!TrySetTimeZone(calendar, tz_id)) {
+		throw NotImplementedException("Unknown TimeZone '%s'", tz_id.GetString());
+	}
 }
 
 timestamp_t ICUDateFunc::GetTimeUnsafe(icu::Calendar *calendar, uint64_t micros) {

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -11,9 +11,7 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/main/client_context.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/function/function_binder.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/main/extension_util.hpp"
 
@@ -60,14 +58,7 @@ struct ICUStrptime : public ICUDateFunc {
 	}
 
 	static uint64_t ToMicros(icu::Calendar *calendar, const ParseResult &parsed, const StrpTimeFormat &format) {
-		// Set TZ first, if any.
-		// Note that empty TZ names are not allowed,
-		// but unknown names will map to GMT.
-		if (!parsed.tz.empty()) {
-			SetTimeZone(calendar, parsed.tz);
-		}
-
-		// Now get the parts in the given time zone
+		// Get the parts in the current time zone
 		uint64_t micros = parsed.GetMicros();
 		calendar->set(UCAL_EXTENDED_YEAR, parsed.data[0]); // strptime doesn't understand eras
 		calendar->set(UCAL_MONTH, parsed.data[1] - 1);
@@ -110,6 +101,11 @@ struct ICUStrptime : public ICUDateFunc {
 						if (parsed.is_special) {
 							return parsed.ToTimestamp();
 						} else {
+							// Set TZ first, if any.
+							if (!parsed.tz.empty()) {
+								SetTimeZone(calendar, parsed.tz);
+							}
+
 							return GetTime(calendar, ToMicros(calendar, parsed, format));
 						}
 					}
@@ -143,7 +139,7 @@ struct ICUStrptime : public ICUDateFunc {
 					    if (format.Parse(input, parsed)) {
 						    if (parsed.is_special) {
 							    return parsed.ToTimestamp();
-						    } else {
+						    } else if (parsed.tz.empty() || TrySetTimeZone(calendar, parsed.tz)) {
 							    timestamp_t result;
 							    if (TryGetTime(calendar, ToMicros(calendar, parsed, format), result)) {
 								    return result;

package/src/duckdb/extension/icu/include/icu-datefunc.hpp

@@ -49,7 +49,9 @@ struct ICUDateFunc {
 	static duckdb::unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
 	                                             vector<duckdb::unique_ptr<Expression>> &arguments);
 
-	//! Sets the time zone for the calendar.
+	//! Tries to set the time zone for the calendar and returns false if it is not valid.
+	static bool TrySetTimeZone(icu::Calendar *calendar, const string_t &tz_id);
+	//! Sets the time zone for the calendar. Throws if it is not valid
 	static void SetTimeZone(icu::Calendar *calendar, const string_t &tz_id);
 	//! Gets the timestamp from the calendar, throwing if it is not in range.
 	static bool TryGetTime(icu::Calendar *calendar, uint64_t micros, timestamp_t &result);

package/src/duckdb/extension/json/buffered_json_reader.cpp

@@ -90,22 +90,16 @@ void JSONFileHandle::ReadAtPosition(char *pointer, idx_t size, idx_t position, b
                                     optional_ptr<FileHandle> override_handle) {
 	if (size != 0) {
 		auto &handle = override_handle ? *override_handle.get() : *file_handle.get();
-		if (can_seek) {
-			handle.Read(pointer, size, position);
-		} else if (sample_run) { // Cache the buffer
-			handle.Read(pointer, size, position);
 
+		if (!cached_buffers.empty() || position < cached_size) {
+			ReadFromCache(pointer, size, position);
+		}
+
+		handle.Read(pointer, size, position);
+		if (file_handle->IsPipe()) { // Cache the buffer
 			cached_buffers.emplace_back(allocator.Allocate(size));
 			memcpy(cached_buffers.back().get(), pointer, size);
 			cached_size += size;
-		} else {
-			if (!cached_buffers.empty() || position < cached_size) {
-				ReadFromCache(pointer, size, position);
-			}
-
-			if (size != 0) {
-				handle.Read(pointer, size, position);
-			}
 		}
 	}
 
@@ -121,30 +115,23 @@ void JSONFileHandle::ReadAtPosition(char *pointer, idx_t size, idx_t position, b
 
 bool JSONFileHandle::Read(char *pointer, idx_t &read_size, idx_t requested_size, bool &file_done, bool sample_run) {
 	D_ASSERT(requested_size != 0);
+	read_size = 0;
 	if (last_read_requested) {
 		return false;
 	}
 
-	if (can_seek) {
-		read_size = ReadInternal(pointer, requested_size);
-		read_position += read_size;
-	} else if (sample_run) { // Cache the buffer
-		read_size = ReadInternal(pointer, requested_size);
-		if (read_size > 0) {
-			cached_buffers.emplace_back(allocator.Allocate(read_size));
-			memcpy(cached_buffers.back().get(), pointer, read_size);
-		}
-		cached_size += read_size;
-		read_position += read_size;
-	} else {
-		read_size = 0;
-		if (!cached_buffers.empty() || read_position < cached_size) {
-			read_size += ReadFromCache(pointer, requested_size, read_position);
-		}
-		if (requested_size != 0) {
-			read_size += ReadInternal(pointer, requested_size);
-		}
+	if (!cached_buffers.empty() || read_position < cached_size) {
+		read_size += ReadFromCache(pointer, requested_size, read_position);
+	}
+
+	auto temp_read_size = ReadInternal(pointer, requested_size);
+	if (file_handle->IsPipe() && temp_read_size != 0) { // Cache the buffer
+		cached_buffers.emplace_back(allocator.Allocate(temp_read_size));
+		memcpy(cached_buffers.back().get(), pointer, temp_read_size);
 	}
+	cached_size += temp_read_size;
+	read_position += temp_read_size;
+	read_size += temp_read_size;
 
 	if (read_size == 0) {
 		last_read_requested = true;

package/src/duckdb/extension/json/json_extension.cpp

@@ -17,12 +17,17 @@
 namespace duckdb {
 
 static DefaultMacro json_macros[] = {
-    {DEFAULT_SCHEMA, "json_group_array", {"x", nullptr}, {{nullptr, nullptr}}, "to_json(list(x))"},
+    {DEFAULT_SCHEMA,
+     "json_group_array",
+     {"x", nullptr},
+     {{nullptr, nullptr}},
+     "CAST('[' || string_agg(CASE WHEN x IS NULL THEN 'null'::JSON ELSE to_json(x) END, ',') || ']' AS JSON)"},
     {DEFAULT_SCHEMA,
      "json_group_object",
-     {"name", "value", nullptr},
+     {"n", "v", nullptr},
      {{nullptr, nullptr}},
-     "to_json(map(list(name), list(value)))"},
+     "CAST('{' || string_agg(to_json(n::VARCHAR) || ':' || CASE WHEN v IS NULL THEN 'null'::JSON ELSE to_json(v) END, "
+     "',') || '}' AS JSON)"},
     {DEFAULT_SCHEMA,
      "json_group_structure",
      {"x", nullptr},

package/src/duckdb/extension/parquet/column_reader.cpp

@@ -319,7 +319,8 @@ void ColumnReader::PreparePageV2(PageHeader &page_hdr) {
 
 	auto compressed_bytes = page_hdr.compressed_page_size - uncompressed_bytes;
 
-	AllocateCompressed(compressed_bytes);
+	ResizeableBuffer compressed_buffer;
+	compressed_buffer.resize(GetAllocator(), compressed_bytes);
 	reader.ReadData(*protocol, compressed_buffer.ptr, compressed_bytes);
 
 	DecompressInternal(chunk->meta_data.codec, compressed_buffer.ptr, compressed_bytes, block->ptr + uncompressed_bytes,
@@ -334,10 +335,6 @@ void ColumnReader::AllocateBlock(idx_t size) {
 	}
 }
 
-void ColumnReader::AllocateCompressed(idx_t size) {
-	compressed_buffer.resize(GetAllocator(), size);
-}
-
 void ColumnReader::PreparePage(PageHeader &page_hdr) {
 	AllocateBlock(page_hdr.uncompressed_page_size + 1);
 	if (chunk->meta_data.codec == CompressionCodec::UNCOMPRESSED) {
@@ -348,7 +345,8 @@ void ColumnReader::PreparePage(PageHeader &page_hdr) {
 		return;
 	}
 
-	AllocateCompressed(page_hdr.compressed_page_size + 1);
+	ResizeableBuffer compressed_buffer;
+	compressed_buffer.resize(GetAllocator(), page_hdr.compressed_page_size + 1);
 	reader.ReadData(*protocol, compressed_buffer.ptr, page_hdr.compressed_page_size);
 
 	DecompressInternal(chunk->meta_data.codec, compressed_buffer.ptr, page_hdr.compressed_page_size, block->ptr,

package/src/duckdb/extension/parquet/column_writer.cpp

@@ -309,6 +309,7 @@ struct PageInformation {
 	idx_t offset = 0;
 	idx_t row_count = 0;
 	idx_t empty_count = 0;
+	idx_t null_count = 0;
 	idx_t estimated_page_size = 0;
 };
 
@@ -388,7 +389,7 @@ protected:
 	virtual unique_ptr<ColumnWriterStatistics> InitializeStatsState();
 
 	//! Initialize the writer for a specific page. Only used for scalar types.
-	virtual unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state);
+	virtual unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state, idx_t page_idx);
 
 	//! Flushes the writer for a specific page. Only used for scalar types.
 	virtual void FlushPageState(WriteStream &temp_writer, ColumnWriterPageState *state);
@@ -427,7 +428,8 @@ void BasicColumnWriter::RegisterToRowGroup(duckdb_parquet::RowGroup &row_group)
 	row_group.columns.push_back(std::move(column_chunk));
 }
 
-unique_ptr<ColumnWriterPageState> BasicColumnWriter::InitializePageState(BasicColumnWriterState &state) {
+unique_ptr<ColumnWriterPageState> BasicColumnWriter::InitializePageState(BasicColumnWriterState &state,
+                                                                         idx_t page_idx) {
 	return nullptr;
 }
 
@@ -463,6 +465,8 @@ void BasicColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *p
 				state.page_info.push_back(new_info);
 				page_info_ref = state.page_info.back();
 			}
+		} else {
+			page_info.null_count++;
 		}
 		vector_index++;
 	}
@@ -502,7 +506,7 @@ void BasicColumnWriter::BeginWrite(ColumnWriterState &state_p) {
 		    MaxValue<idx_t>(NextPowerOfTwo(page_info.estimated_page_size), MemoryStream::DEFAULT_INITIAL_CAPACITY));
 		write_info.write_count = page_info.empty_count;
 		write_info.max_write_count = page_info.row_count;
-		write_info.page_state = InitializePageState(state);
+		write_info.page_state = InitializePageState(state, page_idx);
 
 		write_info.compressed_size = 0;
 		write_info.compressed_data = nullptr;
@@ -796,7 +800,6 @@ public:
 };
 
 struct BaseParquetOperator {
-
 	template <class SRC, class TGT>
 	static void WriteToStream(const TGT &input, WriteStream &ser) {
 		ser.WriteData(const_data_ptr_cast(&input), sizeof(TGT));
@@ -815,6 +818,11 @@ struct BaseParquetOperator {
 	template <class SRC, class TGT>
 	static void HandleStats(ColumnWriterStatistics *stats, TGT target_value) {
 	}
+
+	template <class SRC, class TGT>
+	static idx_t GetRowSize(const Vector &, idx_t) {
+		return sizeof(TGT);
+	}
 };
 
 struct ParquetCastOperator : public BaseParquetOperator {
@@ -936,6 +944,11 @@ struct ParquetStringOperator : public BaseParquetOperator {
 	static uint64_t XXHash64(const TGT &target_value) {
 		return duckdb_zstd::XXH64(target_value.GetData(), target_value.GetSize(), 0);
 	}
+
+	template <class SRC, class TGT>
+	static idx_t GetRowSize(const Vector &vector, idx_t index) {
+		return FlatVector::GetData<string_t>(vector)[index].GetSize();
+	}
 };
 
 struct ParquetIntervalTargetType {
@@ -1066,6 +1079,7 @@ public:
 	// analysis state for integer values for DELTA_BINARY_PACKED/DELTA_LENGTH_BYTE_ARRAY
 	idx_t total_value_count = 0;
 	idx_t total_string_size = 0;
+	uint32_t key_bit_width = 0;
 
 	unordered_map<T, uint32_t> dictionary;
 	duckdb_parquet::Encoding::type encoding;
@@ -1222,11 +1236,12 @@ public:
 		return std::move(result);
 	}
 
-	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state_p) override {
+	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state_p, idx_t page_idx) override {
 		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
-
-		auto result = make_uniq<StandardWriterPageState<SRC, TGT>>(state.total_value_count, state.total_string_size,
-		                                                           state.encoding, state.dictionary);
+		const auto &page_info = state_p.page_info[page_idx];
+		auto result = make_uniq<StandardWriterPageState<SRC, TGT>>(
+		    page_info.row_count - (page_info.empty_count + page_info.null_count), state.total_string_size,
+		    state.encoding, state.dictionary);
 		return std::move(result);
 	}
 
@@ -1335,6 +1350,8 @@ public:
 				}
 			}
 			state.dictionary.clear();
+		} else {
+			state.key_bit_width = RleBpDecoder::ComputeBitWidth(state.dictionary.size());
 		}
 	}
 
@@ -1488,9 +1505,13 @@ public:
 		// bloom filter will be queued for writing in ParquetWriter::BufferBloomFilter one level up
 	}
 
-	// TODO this now vastly over-estimates the page size
 	idx_t GetRowSize(const Vector &vector, const idx_t index, const BasicColumnWriterState &state_p) const override {
-		return sizeof(TGT);
+		auto &state = state_p.Cast<StandardColumnWriterState<SRC>>();
+		if (state.encoding == Encoding::RLE_DICTIONARY) {
+			return (state.key_bit_width + 7) / 8;
+		} else {
+			return OP::template GetRowSize<SRC, TGT>(vector, index);
+		}
 	}
 };
 
@@ -1570,7 +1591,7 @@ public:
 		}
 	}
 
-	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state) override {
+	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state, idx_t page_idx) override {
 		return make_uniq<BooleanWriterPageState>();
 	}
 
@@ -1812,7 +1833,7 @@ public:
 		}
 	}
 
-	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state) override {
+	unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state, idx_t page_idx) override {
 		return make_uniq<EnumWriterPageState>(bit_width);
 	}
 

package/src/duckdb/extension/parquet/include/column_reader.hpp

@@ -160,7 +160,6 @@ protected:
 
 private:
 	void AllocateBlock(idx_t size);
-	void AllocateCompressed(idx_t size);
 	void PrepareRead(parquet_filter_t &filter);
 	void PreparePage(PageHeader &page_hdr);
 	void PrepareDataPage(PageHeader &page_hdr);
@@ -178,7 +177,6 @@ private:
 
 	shared_ptr<ResizeableBuffer> block;
 
-	ResizeableBuffer compressed_buffer;
 	ResizeableBuffer offset_buffer;
 
 	unique_ptr<RleBpDecoder> dict_decoder;

package/src/duckdb/extension/parquet/include/parquet_bss_encoder.hpp

@@ -30,7 +30,6 @@ public:
 	}
 
 	void FinishWrite(WriteStream &writer) {
-		D_ASSERT(count == total_value_count);
 		writer.WriteData(buffer.get(), total_value_count * bit_width);
 	}
 

package/src/duckdb/extension/parquet/include/parquet_dlba_encoder.hpp

@@ -33,9 +33,8 @@ public:
 	}
 
 	void FinishWrite(WriteStream &writer) {
-		D_ASSERT(stream->GetPosition() == total_string_size);
 		dbp_encoder.FinishWrite(writer);
-		writer.WriteData(buffer.get(), total_string_size);
+		writer.WriteData(buffer.get(), stream->GetPosition());
 	}
 
 private:

package/src/duckdb/src/catalog/catalog.cpp

@@ -769,6 +769,12 @@ CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, Cat
 
 	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
 		return {nullptr, nullptr, ErrorData()};
+	}
+	// Check if the default database is actually attached. CreateMissingEntryException will throw binder exception
+	// otherwise.
+	if (!GetCatalogEntry(context, GetDefaultCatalog(retriever))) {
+		auto except = CatalogException("%s with name %s does not exist!", CatalogTypeToString(type), name);
+		return {nullptr, nullptr, ErrorData(except)};
 	} else {
 		auto except = CreateMissingEntryException(retriever, name, type, schemas, error_context);
 		return {nullptr, nullptr, ErrorData(except)};
@@ -805,6 +811,12 @@ CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, vec
 
 	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
 		return {nullptr, nullptr, ErrorData()};
+	}
+	// Check if the default database is actually attached. CreateMissingEntryException will throw binder exception
+	// otherwise.
+	if (!GetCatalogEntry(context, GetDefaultCatalog(retriever))) {
+		auto except = CatalogException("%s with name %s does not exist!", CatalogTypeToString(type), name);
+		return {nullptr, nullptr, ErrorData(except)};
 	} else {
 		auto except = CreateMissingEntryException(retriever, name, type, schemas, error_context);
 		return {nullptr, nullptr, ErrorData(except)};

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -863,7 +863,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
 	}
 
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
+	auto bound_create_info = binder->BindCreateTableCheckpoint(std::move(create_info), schema);
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 

package/src/duckdb/src/catalog/catalog_entry_retriever.cpp

@@ -76,7 +76,7 @@ void CatalogEntryRetriever::Inherit(const CatalogEntryRetriever &parent) {
 	this->search_path = parent.search_path;
 }
 
-CatalogSearchPath &CatalogEntryRetriever::GetSearchPath() {
+const CatalogSearchPath &CatalogEntryRetriever::GetSearchPath() const {
 	if (search_path) {
 		return *search_path;
 	}