duckdb 0.7.2-dev3441.0 → 0.7.2-dev3546.0

package/configure.py

@@ -63,6 +63,8 @@ elif 'DUCKDB_NODE_BINDIR' in os.environ:
             cflags += ['-g']
         if '-O0' in os.environ['DUCKDB_NODE_CFLAGS']:
             cflags += ['-O0']
+        if '-DNDEBUG' in os.environ['DUCKDB_NODE_CFLAGS']:
+            defines += ['NDEBUG']
 
     if 'DUCKDB_NODE_BUILD_CACHE' in os.environ:
         cache = {

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev3441.0",
+  "version": "0.7.2-dev3546.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {
@@ -19,7 +19,7 @@
     "install": "node-pre-gyp install --fallback-to-build",
     "pretest": "node test/support/createdb.js",
     "test": "mocha -R spec --timeout 480000 --expose-gc",
-    "test-path": "mocha -R spec --timeout 480000 --exclude 'test/*.ts'",
+    "test-path": "mocha -R spec --timeout 480000 --expose-gc --exclude 'test/*.ts'",
     "pack": "node-pre-gyp package"
   },
   "directories": {

package/src/duckdb/extension/json/json_functions/json_create.cpp

@@ -639,7 +639,7 @@ public:
 		for (auto &csn : const_struct_names) {
 			result->const_struct_names.emplace(csn.first, make_uniq<Vector>(csn.second->GetValue(0)));
 		}
-		return result;
+		return std::move(result);
 	}
 
 public:

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -276,6 +276,7 @@ static void ReadJSONFunction(ClientContext &context, TableFunctionInput &data_p,
 TableFunction JSONFunctions::GetReadJSONTableFunction(shared_ptr<JSONScanInfo> function_info) {
 	TableFunction table_function({LogicalType::VARCHAR}, ReadJSONFunction, ReadJSONBind,
 	                             JSONGlobalTableFunctionState::Init, JSONLocalTableFunctionState::Init);
+	table_function.name = "read_json";
 
 	JSONScan::TableFunctionDefaults(table_function);
 	table_function.named_parameters["columns"] = LogicalType::ANY;

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

@@ -0,0 +1,42 @@
+#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/function/scalar_macro_function.hpp"
+
+namespace duckdb {
+
+MacroCatalogEntry::MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
+    : FunctionEntry(
+          (info.function->type == MacroType::SCALAR_MACRO ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY),
+          catalog, schema, info),
+      function(std::move(info.function)) {
+	this->temporary = info.temporary;
+	this->internal = info.internal;
+}
+
+ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
+    : MacroCatalogEntry(catalog, schema, info) {
+}
+
+TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
+    : MacroCatalogEntry(catalog, schema, info) {
+}
+
+unique_ptr<CreateMacroInfo> MacroCatalogEntry::GetInfoForSerialization() const {
+	auto info = make_uniq<CreateMacroInfo>(type);
+	info->catalog = catalog.GetName();
+	info->schema = schema.name;
+	info->name = name;
+	info->function = function->Copy();
+	return info;
+}
+void MacroCatalogEntry::Serialize(Serializer &serializer) const {
+	auto info = GetInfoForSerialization();
+	info->Serialize(serializer);
+}
+
+unique_ptr<CreateMacroInfo> MacroCatalogEntry::Deserialize(Deserializer &main_source, ClientContext &context) {
+	return unique_ptr_cast<CreateInfo, CreateMacroInfo>(CreateInfo::Deserialize(main_source));
+}
+
+} // namespace duckdb

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

@@ -145,6 +145,11 @@ void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, bool is_set_sc
 			                       is_set_schema ? "schema" : "search_path", path.ToString());
 		}
 	}
+	if (is_set_schema) {
+		if (new_paths[0].catalog == TEMP_CATALOG || new_paths[0].catalog == SYSTEM_CATALOG) {
+			throw CatalogException("SET schema cannot be set to internal schema \"%s\"", new_paths[0].catalog);
+		}
+	}
 	this->set_paths = std::move(new_paths);
 	SetPaths(set_paths);
 }

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

@@ -84,7 +84,7 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 			throw InternalException("Attempting to create temporary entry \"%s\" in non-temporary catalog", name);
 		}
 		if (!value->temporary && catalog.IsTemporaryCatalog() && name != DEFAULT_SCHEMA) {
-			throw InternalException("Attempting to create non-temporary entry \"%s\" in temporary catalog", name);
+			throw InvalidInputException("Cannot create non-temporary entry \"%s\" in temporary catalog", name);
 		}
 	}
 	// lock the catalog for writing

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -92,6 +92,7 @@ static DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "array_pop_front", {"arr", nullptr}, "arr[2:]"},
 	{DEFAULT_SCHEMA, "array_push_back", {"arr", "e", nullptr}, "list_concat(arr, list_value(e))"},
 	{DEFAULT_SCHEMA, "array_push_front", {"arr", "e", nullptr}, "list_concat(list_value(e), arr)"},
+	{DEFAULT_SCHEMA, "array_to_string", {"arr", "sep", nullptr}, "list_aggr(arr, 'string_agg', sep)"},
 	{DEFAULT_SCHEMA, "generate_subscripts", {"arr", "dim", nullptr}, "unnest(generate_series(1, array_length(arr, dim)))"},
 	{DEFAULT_SCHEMA, "fdiv", {"x", "y", nullptr}, "floor(x/y)"},
 	{DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, "(x-y*floor(x/y))"},

package/src/duckdb/src/common/arrow/arrow_converter.cpp

@@ -33,7 +33,7 @@ struct DuckDBArrowSchemaHolder {
 	std::list<vector<ArrowSchema>> nested_children;
 	std::list<vector<ArrowSchema *>> nested_children_ptr;
 	//! This holds strings created to represent decimal types
-	vector<unique_ptr<char[]>> owned_type_names;
+	vector<unsafe_array_ptr<char>> owned_type_names;
 };
 
 static void ReleaseDuckDBArrowSchema(ArrowSchema *schema) {
@@ -131,7 +131,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	case LogicalTypeId::TIMESTAMP_TZ: {
 		string format = "tsu:" + config_timezone;
-		unique_ptr<char[]> format_ptr = unique_ptr<char[]>(new char[format.size() + 1]);
+		auto format_ptr = make_unsafe_array<char>(format.size() + 1);
 		for (size_t i = 0; i < format.size(); i++) {
 			format_ptr[i] = format[i];
 		}
@@ -156,7 +156,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		uint8_t width, scale;
 		type.GetDecimalProperties(width, scale);
 		string format = "d:" + to_string(width) + "," + to_string(scale);
-		unique_ptr<char[]> format_ptr = unique_ptr<char[]>(new char[format.size() + 1]);
+		auto format_ptr = make_unsafe_array<char>(format.size() + 1);
 		for (size_t i = 0; i < format.size(); i++) {
 			format_ptr[i] = format[i];
 		}
@@ -204,7 +204,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 			InitializeChild(*child.children[type_idx]);
 
 			auto &struct_col_name = child_types[type_idx].first;
-			unique_ptr<char[]> name_ptr = unique_ptr<char[]>(new char[struct_col_name.size() + 1]);
+			auto name_ptr = make_unsafe_array<char>(struct_col_name.size() + 1);
 			for (size_t i = 0; i < struct_col_name.size(); i++) {
 				name_ptr[i] = struct_col_name[i];
 			}

package/src/duckdb/src/common/compressed_file_system.cpp

@@ -19,10 +19,10 @@ void CompressedFile::Initialize(bool write) {
 	this->write = write;
 	stream_data.in_buf_size = compressed_fs.InBufferSize();
 	stream_data.out_buf_size = compressed_fs.OutBufferSize();
-	stream_data.in_buff = unique_ptr<data_t[]>(new data_t[stream_data.in_buf_size]);
+	stream_data.in_buff = make_unsafe_array<data_t>(stream_data.in_buf_size);
 	stream_data.in_buff_start = stream_data.in_buff.get();
 	stream_data.in_buff_end = stream_data.in_buff.get();
-	stream_data.out_buff = unique_ptr<data_t[]>(new data_t[stream_data.out_buf_size]);
+	stream_data.out_buff = make_unsafe_array<data_t>(stream_data.out_buf_size);
 	stream_data.out_buff_start = stream_data.out_buff.get();
 	stream_data.out_buff_end = stream_data.out_buff.get();
 

package/src/duckdb/src/common/constants.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/vector_size.hpp"
+#include "duckdb/common/serializer.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/common/file_system.cpp

@@ -78,7 +78,7 @@ idx_t FileSystem::GetAvailableMemory() {
 }
 
 string FileSystem::GetWorkingDirectory() {
-	auto buffer = unique_ptr<char[]>(new char[PATH_MAX]);
+	auto buffer = make_unsafe_array<char>(PATH_MAX);
 	char *ret = getcwd(buffer.get(), PATH_MAX);
 	if (!ret) {
 		throw IOException("Could not get working directory!");
@@ -138,7 +138,7 @@ string FileSystem::GetWorkingDirectory() {
 	if (count == 0) {
 		throw IOException("Could not get working directory!");
 	}
-	auto buffer = unique_ptr<char[]>(new char[count]);
+	auto buffer = make_unsafe_array<char>(count);
 	idx_t ret = GetCurrentDirectory(count, buffer.get());
 	if (count != ret + 1) {
 		throw IOException("Could not get working directory!");

package/src/duckdb/src/common/row_operations/row_gather.cpp

@@ -95,8 +95,8 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
 	// Build the gather locations
-	auto data_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
-	auto mask_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
+	auto data_locations = make_unsafe_array<data_ptr_t>(count);
+	auto mask_locations = make_unsafe_array<data_ptr_t>(count);
 	for (idx_t i = 0; i < count; i++) {
 		auto row_idx = row_sel.get_index(i);
 		auto row = ptrs[row_idx];

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -123,7 +123,7 @@ string BinaryDeserializer::ReadString() {
 	if (size == 0) {
 		return string();
 	}
-	auto buffer = unique_ptr<data_t[]>(new data_t[size]);
+	auto buffer = make_unsafe_array<data_t>(size);
 	ReadData(buffer.get(), size);
 	return string((char *)buffer.get(), size);
 }

package/src/duckdb/src/common/serializer/buffered_file_reader.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 
 BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, optional_ptr<ClientContext> context,
                                        FileLockType lock_type, optional_ptr<FileOpener> opener)
-    : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), total_read(0),
+    : fs(fs), data(make_unsafe_array<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0), total_read(0),
       context(context) {
 	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener.get());
 	file_size = fs.GetFileSize(*handle);

package/src/duckdb/src/common/serializer/buffered_file_writer.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 constexpr uint8_t BufferedFileWriter::DEFAULT_OPEN_FLAGS;
 
 BufferedFileWriter::BufferedFileWriter(FileSystem &fs, const string &path_p, uint8_t open_flags)
-    : fs(fs), path(path_p), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), total_written(0) {
+    : fs(fs), path(path_p), data(make_unsafe_array<data_t>(FILE_BUFFER_SIZE)), offset(0), total_written(0) {
 	handle = fs.OpenFile(path, open_flags, FileLockType::WRITE_LOCK);
 }
 

package/src/duckdb/src/common/serializer/buffered_serializer.cpp

@@ -5,10 +5,11 @@
 namespace duckdb {
 
 BufferedSerializer::BufferedSerializer(idx_t maximum_size)
-    : BufferedSerializer(unique_ptr<data_t[]>(new data_t[maximum_size]), maximum_size) {
+    : BufferedSerializer(make_unsafe_array<data_t>(maximum_size), maximum_size) {
 }
 
-BufferedSerializer::BufferedSerializer(unique_ptr<data_t[]> data, idx_t size) : maximum_size(size), data(data.get()) {
+BufferedSerializer::BufferedSerializer(unsafe_array_ptr<data_t> data, idx_t size)
+    : maximum_size(size), data(data.get()) {
 	blob.size = 0;
 	blob.data = std::move(data);
 }
@@ -25,7 +26,7 @@ void BufferedSerializer::WriteData(const_data_ptr_t buffer, idx_t write_size) {
 		auto new_data = new data_t[maximum_size];
 		memcpy(new_data, data, blob.size);
 		data = new_data;
-		blob.data = unique_ptr<data_t[]>(new_data);
+		blob.data = unsafe_array_ptr<data_t>(new_data);
 	}
 
 	memcpy(data + blob.size, buffer, write_size);

package/src/duckdb/src/common/serializer.cpp

@@ -8,7 +8,7 @@ string Deserializer::Read() {
 	if (size == 0) {
 		return string();
 	}
-	auto buffer = unique_ptr<data_t[]>(new data_t[size]);
+	auto buffer = make_unsafe_array<data_t>(size);
 	ReadData(buffer.get(), size);
 	return string((char *)buffer.get(), size);
 }

package/src/duckdb/src/common/sort/radix_sort.cpp

@@ -17,7 +17,7 @@ static void SortTiedBlobs(BufferManager &buffer_manager, const data_ptr_t datapt
 		return;
 	}
 	// Fill pointer array for sorting
-	auto ptr_block = unique_ptr<data_ptr_t[]>(new data_ptr_t[end - start]);
+	auto ptr_block = make_unsafe_array<data_ptr_t>(end - start);
 	auto entry_ptrs = (data_ptr_t *)ptr_block.get();
 	for (idx_t i = start; i < end; i++) {
 		entry_ptrs[i - start] = row_ptr;
@@ -158,7 +158,7 @@ inline void InsertionSort(const data_ptr_t orig_ptr, const data_ptr_t temp_ptr,
 	const data_ptr_t target_ptr = swap ? orig_ptr : temp_ptr;
 	if (count > 1) {
 		const idx_t total_offset = col_offset + offset;
-		auto temp_val = unique_ptr<data_t[]>(new data_t[row_width]);
+		auto temp_val = make_unsafe_array<data_t>(row_width);
 		const data_ptr_t val = temp_val.get();
 		const auto comp_width = total_comp_width - offset;
 		for (idx_t i = 1; i < count; i++) {
@@ -249,7 +249,7 @@ void RadixSort(BufferManager &buffer_manager, const data_ptr_t &dataptr, const i
 		RadixSortLSD(buffer_manager, dataptr, count, col_offset, sort_layout.entry_size, sorting_size);
 	} else {
 		auto temp_block = buffer_manager.Allocate(MaxValue(count * sort_layout.entry_size, (idx_t)Storage::BLOCK_SIZE));
-		auto preallocated_array = unique_ptr<idx_t[]>(new idx_t[sorting_size * SortConstants::MSD_RADIX_LOCATIONS]);
+		auto preallocated_array = make_unsafe_array<idx_t>(sorting_size * SortConstants::MSD_RADIX_LOCATIONS);
 		RadixSortMSD(dataptr, temp_block.Ptr(), count, col_offset, sort_layout.entry_size, sorting_size, 0,
 		             preallocated_array.get(), false);
 	}
@@ -291,7 +291,7 @@ void LocalSortState::SortInMemory() {
 	// Radix sort and break ties until no more ties, or until all columns are sorted
 	idx_t sorting_size = 0;
 	idx_t col_offset = 0;
-	unique_ptr<bool[]> ties_ptr;
+	unsafe_array_ptr<bool> ties_ptr;
 	bool *ties = nullptr;
 	bool contains_string = false;
 	for (idx_t i = 0; i < sort_layout->column_count; i++) {
@@ -305,7 +305,7 @@ void LocalSortState::SortInMemory() {
 		if (!ties) {
 			// This is the first sort
 			RadixSort(*buffer_manager, dataptr, count, col_offset, sorting_size, *sort_layout, contains_string);
-			ties_ptr = unique_ptr<bool[]>(new bool[count]);
+			ties_ptr = make_unsafe_array<bool>(count);
 			ties = ties_ptr.get();
 			std::fill_n(ties, count - 1, true);
 			ties[count - 1] = false;

package/src/duckdb/src/common/string_util.cpp

@@ -277,7 +277,7 @@ vector<string> StringUtil::TopNStrings(vector<pair<string, idx_t>> scores, idx_t
 
 struct LevenshteinArray {
 	LevenshteinArray(idx_t len1, idx_t len2) : len1(len1) {
-		dist = unique_ptr<idx_t[]>(new idx_t[len1 * len2]);
+		dist = make_unsafe_array<idx_t>(len1 * len2);
 	}
 
 	idx_t &Score(idx_t i, idx_t j) {
@@ -286,7 +286,7 @@ struct LevenshteinArray {
 
 private:
 	idx_t len1;
-	unique_ptr<idx_t[]> dist;
+	unsafe_array_ptr<idx_t> dist;
 
 	idx_t GetIndex(idx_t i, idx_t j) {
 		return j * len1 + i;

package/src/duckdb/src/common/types/bit.cpp

@@ -78,7 +78,7 @@ void Bit::ToString(string_t bits, char *output) {
 
 string Bit::ToString(string_t str) {
 	auto len = BitLength(str);
-	auto buffer = unique_ptr<char[]>(new char[len]);
+	auto buffer = make_unsafe_array<char>(len);
 	ToString(str, buffer.get());
 	return string(buffer.get(), len);
 }
@@ -140,7 +140,7 @@ void Bit::ToBit(string_t str, string_t &output_str) {
 
 string Bit::ToBit(string_t str) {
 	auto bit_len = GetBitSize(str);
-	auto buffer = unique_ptr<char[]>(new char[bit_len]);
+	auto buffer = make_unsafe_array<char>(bit_len);
 	string_t output_str(buffer.get(), bit_len);
 	Bit::ToBit(str, output_str);
 	return output_str.GetString();

package/src/duckdb/src/common/types/blob.cpp

@@ -64,7 +64,7 @@ void Blob::ToString(string_t blob, char *output) {
 
 string Blob::ToString(string_t blob) {
 	auto str_len = GetStringSize(blob);
-	auto buffer = unique_ptr<char[]>(new char[str_len]);
+	auto buffer = make_unsafe_array<char>(str_len);
 	Blob::ToString(blob, buffer.get());
 	return string(buffer.get(), str_len);
 }
@@ -136,7 +136,7 @@ void Blob::ToBlob(string_t str, data_ptr_t output) {
 
 string Blob::ToBlob(string_t str) {
 	auto blob_len = GetBlobSize(str);
-	auto buffer = unique_ptr<char[]>(new char[blob_len]);
+	auto buffer = make_unsafe_array<char>(blob_len);
 	Blob::ToBlob(str, (data_ptr_t)buffer.get());
 	return string(buffer.get(), blob_len);
 }

package/src/duckdb/src/common/types/data_chunk.cpp

@@ -291,8 +291,8 @@ void DataChunk::Slice(DataChunk &other, const SelectionVector &sel, idx_t count_
 	}
 }
 
-unique_ptr<UnifiedVectorFormat[]> DataChunk::ToUnifiedFormat() {
-	auto orrified_data = unique_ptr<UnifiedVectorFormat[]>(new UnifiedVectorFormat[ColumnCount()]);
+unsafe_array_ptr<UnifiedVectorFormat> DataChunk::ToUnifiedFormat() {
+	auto orrified_data = make_unsafe_array<UnifiedVectorFormat>(ColumnCount());
 	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
 		data[col_idx].ToUnifiedFormat(size(), orrified_data[col_idx]);
 	}

package/src/duckdb/src/common/types/date.cpp

@@ -362,7 +362,7 @@ string Date::ToString(date_t date) {
 	Date::Convert(date, date_units[0], date_units[1], date_units[2]);
 
 	auto length = DateToStringCast::Length(date_units, year_length, add_bc);
-	auto buffer = unique_ptr<char[]>(new char[length]);
+	auto buffer = make_unsafe_array<char>(length);
 	DateToStringCast::Format(buffer.get(), date_units, year_length, add_bc);
 	return string(buffer.get(), length);
 }

package/src/duckdb/src/common/types/decimal.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 template <class SIGNED, class UNSIGNED>
 string TemplatedDecimalToString(SIGNED value, uint8_t width, uint8_t scale) {
 	auto len = DecimalToString::DecimalLength<SIGNED, UNSIGNED>(value, width, scale);
-	auto data = unique_ptr<char[]>(new char[len + 1]);
+	auto data = make_unsafe_array<char>(len + 1);
 	DecimalToString::FormatDecimal<SIGNED, UNSIGNED>(value, width, scale, data.get(), len);
 	return string(data.get(), len);
 }
@@ -25,7 +25,7 @@ string Decimal::ToString(int64_t value, uint8_t width, uint8_t scale) {
 
 string Decimal::ToString(hugeint_t value, uint8_t width, uint8_t scale) {
 	auto len = HugeintToStringCast::DecimalLength(value, width, scale);
-	auto data = unique_ptr<char[]>(new char[len + 1]);
+	auto data = make_unsafe_array<char>(len + 1);
 	HugeintToStringCast::FormatDecimal(value, width, scale, data.get(), len);
 	return string(data.get(), len);
 }

package/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp

@@ -1,7 +1,7 @@
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/fast_mem.hpp"
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/types/row/tuple_data_collection.hpp"
-#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -314,6 +314,19 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 	const auto child_list_entries = (list_entry_t *)child_list_data.data;
 	const auto &child_list_validity = child_list_data.validity;
 
+	// Figure out actual child list size (differs from ListVector::GetListSize if dict/const vector)
+	idx_t child_list_child_count = ListVector::GetListSize(source_v);
+	for (idx_t i = 0; i < append_count; i++) {
+		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
+		if (!list_validity.RowIsValid(list_idx)) {
+			continue;
+		}
+		const auto &list_entry = list_entries[list_idx];
+		const auto &list_offset = list_entry.offset;
+		const auto &list_length = list_entry.length;
+		child_list_child_count = MaxValue<idx_t>(child_list_child_count, list_offset + list_length);
+	}
+
 	// Target
 	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
 
@@ -322,7 +335,6 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 	child_format.combined_list_data = make_uniq<CombinedListData>();
 	auto &combined_list_data = *child_format.combined_list_data;
 	auto &combined_list_entries = combined_list_data.combined_list_entries;
-	const auto child_list_child_count = ListVector::GetListSize(source_v);
 	SelectionVector combined_sel(child_list_child_count);
 	for (idx_t i = 0; i < child_list_child_count; i++) {
 		combined_sel.set_index(i, 0);

package/src/duckdb/src/common/types/selection_vector.cpp

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 SelectionData::SelectionData(idx_t count) {
-	owned_data = unique_ptr<sel_t[]>(new sel_t[count]);
+	owned_data = make_unsafe_array<sel_t>(count);
 #ifdef DEBUG
 	for (idx_t i = 0; i < count; i++) {
 		owned_data[i] = std::numeric_limits<sel_t>::max();

package/src/duckdb/src/common/types/time.cpp

@@ -158,7 +158,7 @@ string Time::ToString(dtime_t time) {
 
 	char micro_buffer[6];
 	auto length = TimeToStringCast::Length(time_units, micro_buffer);
-	auto buffer = unique_ptr<char[]>(new char[length]);
+	auto buffer = make_unsafe_array<char>(length);
 	TimeToStringCast::Format(buffer.get(), length, time_units, micro_buffer);
 	return string(buffer.get(), length);
 }

package/src/duckdb/src/common/types/vector.cpp

@@ -297,7 +297,7 @@ void Vector::Resize(idx_t cur_size, idx_t new_size) {
 	}
 	for (auto &data_to_resize : to_resize) {
 		if (!data_to_resize.is_nested) {
-			auto new_data = unique_ptr<data_t[]>(new data_t[new_size * data_to_resize.type_size]);
+			auto new_data = make_unsafe_array<data_t>(new_size * data_to_resize.type_size);
 			memcpy(new_data.get(), data_to_resize.data, cur_size * data_to_resize.type_size * sizeof(data_t));
 			data_to_resize.buffer->SetData(std::move(new_data));
 			data_to_resize.vec.data = data_to_resize.buffer->GetData();
@@ -920,7 +920,7 @@ void Vector::Serialize(idx_t count, Serializer &serializer) {
 	if (TypeIsConstantSize(type.InternalType())) {
 		// constant size type: simple copy
 		idx_t write_size = GetTypeIdSize(type.InternalType()) * count;
-		auto ptr = unique_ptr<data_t[]>(new data_t[write_size]);
+		auto ptr = make_unsafe_array<data_t>(write_size);
 		VectorOperations::WriteToStorage(*this, count, ptr.get());
 		serializer.WriteData(ptr.get(), write_size);
 	} else {
@@ -947,7 +947,7 @@ void Vector::Serialize(idx_t count, Serializer &serializer) {
 			auto list_size = ListVector::GetListSize(*this);
 
 			// serialize the list entries in a flat array
-			auto data = unique_ptr<list_entry_t[]>(new list_entry_t[count]);
+			auto data = make_unsafe_array<list_entry_t>(count);
 			auto source_array = (list_entry_t *)vdata.data;
 			for (idx_t i = 0; i < count; i++) {
 				auto idx = vdata.sel->get_index(i);
@@ -988,7 +988,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 	if (TypeIsConstantSize(logical_type.InternalType())) {
 		// constant size type: simple copy
 		idx_t write_size = GetTypeIdSize(logical_type.InternalType()) * count;
-		auto ptr = unique_ptr<data_t[]>(new data_t[write_size]);
+		auto ptr = make_unsafe_array<data_t>(write_size);
 		VectorOperations::WriteToStorage(*this, count, ptr.get());
 		serializer.WriteProperty("data", ptr.get(), write_size);
 	} else {
@@ -1027,7 +1027,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 			auto list_size = ListVector::GetListSize(*this);
 
 			// serialize the list entries in a flat array
-			auto entries = unique_ptr<list_entry_t[]>(new list_entry_t[count]);
+			auto entries = make_unsafe_array<list_entry_t>(count);
 			auto source_array = (list_entry_t *)vdata.data;
 			for (idx_t i = 0; i < count; i++) {
 				auto idx = vdata.sel->get_index(i);
@@ -1071,7 +1071,7 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 	if (TypeIsConstantSize(logical_type.InternalType())) {
 		// constant size type: read fixed amount of data
 		auto column_size = GetTypeIdSize(logical_type.InternalType()) * count;
-		auto ptr = unique_ptr<data_t[]>(new data_t[column_size]);
+		auto ptr = make_unsafe_array<data_t>(column_size);
 		deserializer.ReadProperty("data", ptr.get(), column_size);
 
 		VectorOperations::ReadFromStorage(ptr.get(), count, *this);
@@ -1158,7 +1158,7 @@ void Vector::Deserialize(idx_t count, Deserializer &source) {
 	if (TypeIsConstantSize(type.InternalType())) {
 		// constant size type: read fixed amount of data from
 		auto column_size = GetTypeIdSize(type.InternalType()) * count;
-		auto ptr = unique_ptr<data_t[]>(new data_t[column_size]);
+		auto ptr = make_unsafe_array<data_t>(column_size);
 		source.ReadData(ptr.get(), column_size);
 
 		VectorOperations::ReadFromStorage(ptr.get(), count, *this);
@@ -1868,7 +1868,7 @@ idx_t ListVector::GetListSize(const Vector &vec) {
 		return ListVector::GetListSize(child);
 	}
 	D_ASSERT(vec.auxiliary);
-	return ((VectorListBuffer &)*vec.auxiliary).size;
+	return ((VectorListBuffer &)*vec.auxiliary).GetSize();
 }
 
 idx_t ListVector::GetListCapacity(const Vector &vec) {
@@ -1877,7 +1877,7 @@ idx_t ListVector::GetListCapacity(const Vector &vec) {
 		return ListVector::GetListSize(child);
 	}
 	D_ASSERT(vec.auxiliary);
-	return ((VectorListBuffer &)*vec.auxiliary).capacity;
+	return ((VectorListBuffer &)*vec.auxiliary).GetCapacity();
 }
 
 void ListVector::ReferenceEntry(Vector &vector, Vector &other) {
@@ -1894,7 +1894,7 @@ void ListVector::SetListSize(Vector &vec, idx_t size) {
 		auto &child = DictionaryVector::Child(vec);
 		ListVector::SetListSize(child, size);
 	}
-	((VectorListBuffer &)*vec.auxiliary).size = size;
+	((VectorListBuffer &)*vec.auxiliary).SetSize(size);
 }
 
 void ListVector::Append(Vector &target, const Vector &source, idx_t source_size, idx_t source_offset) {

package/src/duckdb/src/common/types/vector_buffer.cpp

@@ -58,12 +58,12 @@ VectorStructBuffer::~VectorStructBuffer() {
 }
 
 VectorListBuffer::VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER), capacity(initial_capacity), child(std::move(vector)) {
+    : VectorBuffer(VectorBufferType::LIST_BUFFER), child(std::move(vector)), capacity(initial_capacity) {
 }
 
 VectorListBuffer::VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER), capacity(initial_capacity),
-      child(make_uniq<Vector>(ListType::GetChildType(list_type), initial_capacity)) {
+    : VectorBuffer(VectorBufferType::LIST_BUFFER),
+      child(make_uniq<Vector>(ListType::GetChildType(list_type), initial_capacity)), capacity(initial_capacity) {
 }
 
 void VectorListBuffer::Reserve(idx_t to_reserve) {
@@ -96,6 +96,14 @@ void VectorListBuffer::PushBack(const Value &insert) {
 	child->SetValue(size++, insert);
 }
 
+void VectorListBuffer::SetCapacity(idx_t new_capacity) {
+	this->capacity = new_capacity;
+}
+
+void VectorListBuffer::SetSize(idx_t new_size) {
+	this->size = new_size;
+}
+
 VectorListBuffer::~VectorListBuffer() {
 }
 

package/src/duckdb/src/common/types/vector_cache.cpp

@@ -16,7 +16,7 @@ public:
 			owned_data = allocator.Allocate(capacity * GetTypeIdSize(internal_type));
 			// child data of the list
 			auto &child_type = ListType::GetChildType(type);
-			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type));
+			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type, capacity));
 			auto child_vector = make_uniq<Vector>(child_type, false, false);
 			auxiliary = make_shared<VectorListBuffer>(std::move(child_vector));
 			break;
@@ -24,7 +24,7 @@ public:
 		case PhysicalType::STRUCT: {
 			auto &child_types = StructType::GetChildTypes(type);
 			for (auto &child_type : child_types) {
-				child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type.second));
+				child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type.second, capacity));
 			}
 			auto struct_buffer = make_shared<VectorStructBuffer>(type);
 			auxiliary = std::move(struct_buffer);
@@ -48,13 +48,13 @@ public:
 			// reinitialize the VectorListBuffer
 			AssignSharedPointer(result.auxiliary, auxiliary);
 			// propagate through child
+			auto &child_cache = (VectorCacheBuffer &)*child_caches[0];
 			auto &list_buffer = (VectorListBuffer &)*result.auxiliary;
-			list_buffer.capacity = capacity;
-			list_buffer.size = 0;
+			list_buffer.SetCapacity(child_cache.capacity);
+			list_buffer.SetSize(0);
 			list_buffer.SetAuxiliaryData(nullptr);
 
 			auto &list_child = list_buffer.GetChild();
-			auto &child_cache = (VectorCacheBuffer &)*child_caches[0];
 			child_cache.ResetFromCache(list_child, child_caches[0]);
 			break;
 		}