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

package/src/duckdb/src/planner/operator/logical_simple.cpp

@@ -1,7 +1,11 @@
 #include "duckdb/planner/operator/logical_simple.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
+#include "duckdb/parser/parsed_data/attach_info.hpp"
 #include "duckdb/parser/parsed_data/drop_info.hpp"
 #include "duckdb/parser/parsed_data/load_info.hpp"
+#include "duckdb/parser/parsed_data/transaction_info.hpp"
+#include "duckdb/parser/parsed_data/vacuum_info.hpp"
+#include "duckdb/parser/parsed_data/detach_info.hpp"
 
 namespace duckdb {
 
@@ -9,16 +13,28 @@ void LogicalSimple::Serialize(FieldWriter &writer) const {
 	writer.WriteField<LogicalOperatorType>(type);
 	switch (type) {
 	case LogicalOperatorType::LOGICAL_ALTER:
-		static_cast<const AlterInfo &>(*info).Serialize(writer.GetSerializer());
+		info->Cast<AlterInfo>().Serialize(writer.GetSerializer());
 		break;
 	case LogicalOperatorType::LOGICAL_DROP:
-		static_cast<const DropInfo &>(*info).Serialize(writer.GetSerializer());
+		info->Cast<DropInfo>().Serialize(writer.GetSerializer());
 		break;
 	case LogicalOperatorType::LOGICAL_LOAD:
-		static_cast<const LoadInfo &>(*info).Serialize(writer.GetSerializer());
+		info->Cast<LoadInfo>().Serialize(writer.GetSerializer());
+		break;
+	case LogicalOperatorType::LOGICAL_VACUUM:
+		info->Cast<VacuumInfo>().Serialize(writer.GetSerializer());
+		break;
+	case LogicalOperatorType::LOGICAL_ATTACH:
+		info->Cast<AttachInfo>().Serialize(writer.GetSerializer());
+		break;
+	case LogicalOperatorType::LOGICAL_DETACH:
+		info->Cast<DetachInfo>().Serialize(writer.GetSerializer());
+		break;
+	case LogicalOperatorType::LOGICAL_TRANSACTION:
+		info->Cast<TransactionInfo>().Serialize(writer.GetSerializer());
 		break;
 	default:
-		throw NotImplementedException(LogicalOperatorToString(type));
+		throw InternalException(LogicalOperatorToString(type));
 	}
 }
 
@@ -35,8 +51,20 @@ unique_ptr<LogicalOperator> LogicalSimple::Deserialize(LogicalDeserializationSta
 	case LogicalOperatorType::LOGICAL_LOAD:
 		parse_info = LoadInfo::Deserialize(reader.GetSource());
 		break;
+	case LogicalOperatorType::LOGICAL_VACUUM:
+		parse_info = VacuumInfo::Deserialize(reader.GetSource());
+		break;
+	case LogicalOperatorType::LOGICAL_ATTACH:
+		parse_info = AttachInfo::Deserialize(reader.GetSource());
+		break;
+	case LogicalOperatorType::LOGICAL_DETACH:
+		parse_info = DetachInfo::Deserialize(reader.GetSource());
+		break;
+	case LogicalOperatorType::LOGICAL_TRANSACTION:
+		parse_info = TransactionInfo::Deserialize(reader.GetSource());
+		break;
 	default:
-		throw NotImplementedException(LogicalOperatorToString(state.type));
+		throw InternalException(LogicalOperatorToString(state.type));
 	}
 	return make_uniq<LogicalSimple>(type, std::move(parse_info));
 }

package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp

@@ -6,25 +6,15 @@
 namespace duckdb {
 void BoundCreateTableInfo::Serialize(Serializer &serializer) const {
 	serializer.WriteOptional(base);
-	serializer.WriteList(constraints);
-	serializer.WriteList(bound_constraints);
-	serializer.WriteList(bound_defaults);
-	serializer.WriteOptional(query);
 }
 
 unique_ptr<BoundCreateTableInfo> BoundCreateTableInfo::Deserialize(Deserializer &source,
                                                                    PlanDeserializationState &state) {
-	auto create_info_base = source.ReadOptional<CreateInfo>();
-	// Get schema from the catalog to create BoundCreateTableInfo
-	auto schema_name = create_info_base->schema;
-	auto catalog = create_info_base->catalog;
-	auto &schema_catalog_entry = Catalog::GetSchema(state.context, catalog, schema_name);
-
-	auto result = make_uniq<BoundCreateTableInfo>(schema_catalog_entry, std::move(create_info_base));
-	source.ReadList<Constraint>(result->constraints);
-	source.ReadList<BoundConstraint>(result->bound_constraints);
-	source.ReadList<Expression>(result->bound_defaults, state);
-	result->query = source.ReadOptional<LogicalOperator>(state);
-	return result;
+	auto info = source.ReadOptional<CreateInfo>();
+	auto schema_name = info->schema;
+	auto catalog = info->catalog;
+	auto binder = Binder::CreateBinder(state.context);
+	auto bound_info = binder->BindCreateTableInfo(std::move(info));
+	return bound_info;
 }
 } // namespace duckdb

package/src/duckdb/src/planner/planner.cpp

@@ -143,24 +143,11 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 
 static bool OperatorSupportsSerialization(LogicalOperator &op) {
 	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_INSERT:
-	case LogicalOperatorType::LOGICAL_UPDATE:
-	case LogicalOperatorType::LOGICAL_DELETE:
 	case LogicalOperatorType::LOGICAL_PREPARE:
 	case LogicalOperatorType::LOGICAL_EXECUTE:
-	case LogicalOperatorType::LOGICAL_ALTER:
-	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
 	case LogicalOperatorType::LOGICAL_PRAGMA:
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
 	case LogicalOperatorType::LOGICAL_EXPLAIN:
 	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-	case LogicalOperatorType::LOGICAL_VACUUM:
 		// unsupported (for now)
 		return false;
 	default:
@@ -175,6 +162,10 @@ static bool OperatorSupportsSerialization(LogicalOperator &op) {
 }
 
 void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op, bound_parameter_map_t *map) {
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+	// if alternate verification is enabled we run the original operator
+	return;
+#endif
 	if (!op || !ClientConfig::GetConfig(context).verify_serializer) {
 		return;
 	}

package/src/duckdb/src/storage/arena_allocator.cpp

@@ -64,7 +64,7 @@ data_ptr_t ArenaAllocator::Allocate(idx_t len) {
 		do {
 			current_capacity *= 2;
 		} while (current_capacity < len);
-		auto new_chunk = make_uniq<ArenaChunk>(allocator, current_capacity);
+		auto new_chunk = make_unsafe_uniq<ArenaChunk>(allocator, current_capacity);
 		if (head) {
 			head->prev = new_chunk.get();
 			new_chunk->next = std::move(head);

package/src/duckdb/src/storage/buffer/buffer_handle.cpp

@@ -7,7 +7,8 @@ namespace duckdb {
 BufferHandle::BufferHandle() : handle(nullptr), node(nullptr) {
 }
 
-BufferHandle::BufferHandle(shared_ptr<BlockHandle> handle, FileBuffer *node) : handle(std::move(handle)), node(node) {
+BufferHandle::BufferHandle(shared_ptr<BlockHandle> handle_p, FileBuffer *node_p)
+    : handle(std::move(handle_p)), node(node_p) {
 }
 
 BufferHandle::BufferHandle(BufferHandle &&other) noexcept {
@@ -29,16 +30,6 @@ bool BufferHandle::IsValid() const {
 	return node != nullptr;
 }
 
-data_ptr_t BufferHandle::Ptr() const {
-	D_ASSERT(IsValid());
-	return node->buffer;
-}
-
-data_ptr_t BufferHandle::Ptr() {
-	D_ASSERT(IsValid());
-	return node->buffer;
-}
-
 void BufferHandle::Destroy() {
 	if (!handle || !IsValid()) {
 		return;

package/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp

@@ -32,7 +32,7 @@ void WriteOverflowStringsToDisk::WriteString(string_t string, block_id_t &result
 	MiniZStream s;
 	size_t compressed_size = 0;
 	compressed_size = s.MaxCompressedLength(uncompressed_size);
-	auto compressed_buf = unique_ptr<data_t[]>(new data_t[compressed_size]);
+	auto compressed_buf = make_unsafe_array<data_t>(compressed_size);
 	s.Compress((const char *)string.GetData(), uncompressed_size, (char *)compressed_buf.get(), &compressed_size);
 	string_t compressed_string((const char *)compressed_buf.get(), compressed_size);
 

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -337,7 +337,6 @@ void CheckpointWriter::WriteIndex(IndexCatalogEntry &index_catalog) {
 }
 
 void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader) {
-
 	// deserialize the index metadata
 	auto info = IndexCatalogEntry::Deserialize(reader, context);
 
@@ -361,10 +360,17 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	}
 
 	// bind the parsed expressions
+	// add the table to the bind context
 	auto binder = Binder::CreateBinder(context);
-	auto &table_ref = info->table->Cast<TableRef>();
-	auto bound_table = binder->Bind(table_ref);
-	D_ASSERT(bound_table->type == TableReferenceType::BASE_TABLE);
+	vector<LogicalType> column_types;
+	vector<string> column_names;
+	for (auto &col : table_catalog.GetColumns().Logical()) {
+		column_types.push_back(col.Type());
+		column_names.push_back(col.Name());
+	}
+	vector<column_t> column_ids;
+	binder->bind_context.AddBaseTable(0, info->table->table_name, column_names, column_types, column_ids,
+	                                  &table_catalog);
 	IndexBinder idx_binder(*binder, context);
 	unbound_expressions.reserve(parsed_expressions.size());
 	for (auto &expr : parsed_expressions) {
@@ -419,7 +425,7 @@ void CheckpointWriter::WriteMacro(ScalarMacroCatalogEntry &macro) {
 }
 
 void CheckpointReader::ReadMacro(ClientContext &context, MetaBlockReader &reader) {
-	auto info = ScalarMacroCatalogEntry::Deserialize(reader, context);
+	auto info = MacroCatalogEntry::Deserialize(reader, context);
 	catalog.CreateFunction(context, *info);
 }
 
@@ -428,7 +434,7 @@ void CheckpointWriter::WriteTableMacro(TableMacroCatalogEntry &macro) {
 }
 
 void CheckpointReader::ReadTableMacro(ClientContext &context, MetaBlockReader &reader) {
-	auto info = TableMacroCatalogEntry::Deserialize(reader, context);
+	auto info = MacroCatalogEntry::Deserialize(reader, context);
 	catalog.CreateFunction(context, *info);
 }
 

package/src/duckdb/src/storage/compression/string_uncompressed.cpp

@@ -292,13 +292,13 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 		offset += 2 * sizeof(uint32_t);
 
 		data_ptr_t decompression_ptr;
-		unique_ptr<data_t[]> decompression_buffer;
+		unsafe_array_ptr<data_t> decompression_buffer;
 
 		// If string is in single block we decompress straight from it, else we copy first
 		if (remaining <= Storage::BLOCK_SIZE - sizeof(block_id_t) - offset) {
 			decompression_ptr = handle.Ptr() + offset;
 		} else {
-			decompression_buffer = unique_ptr<data_t[]>(new data_t[compressed_size]);
+			decompression_buffer = make_unsafe_array<data_t>(compressed_size);
 			auto target_ptr = decompression_buffer.get();
 
 			// now append the string to the single buffer

package/src/duckdb/src/storage/statistics/list_stats.cpp

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 void ListStats::Construct(BaseStatistics &stats) {
-	stats.child_stats = unique_ptr<BaseStatistics[]>(new BaseStatistics[1]);
+	stats.child_stats = unsafe_array_ptr<BaseStatistics>(new BaseStatistics[1]);
 	BaseStatistics::Construct(stats.child_stats[0], ListType::GetChildType(stats.GetType()));
 }
 

package/src/duckdb/src/storage/statistics/struct_stats.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 
 void StructStats::Construct(BaseStatistics &stats) {
 	auto &child_types = StructType::GetChildTypes(stats.GetType());
-	stats.child_stats = unique_ptr<BaseStatistics[]>(new BaseStatistics[child_types.size()]);
+	stats.child_stats = unsafe_array_ptr<BaseStatistics>(new BaseStatistics[child_types.size()]);
 	for (idx_t i = 0; i < child_types.size(); i++) {
 		BaseStatistics::Construct(stats.child_stats[i], child_types[i].second);
 	}

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 50;
+const uint64_t VERSION_NUMBER = 51;
 
 struct StorageVersionInfo {
 	const char *version_name;

package/src/duckdb/src/storage/table/row_group.cpp

@@ -155,7 +155,7 @@ void ColumnScanState::Initialize(const LogicalType &type) {
 
 void CollectionScanState::Initialize(const vector<LogicalType> &types) {
 	auto &column_ids = GetColumnIds();
-	column_scans = unique_ptr<ColumnScanState[]>(new ColumnScanState[column_ids.size()]);
+	column_scans = make_unsafe_array<ColumnScanState>(column_ids.size());
 	for (idx_t i = 0; i < column_ids.size(); i++) {
 		if (column_ids[i] == COLUMN_IDENTIFIER_ROW_ID) {
 			continue;
@@ -695,7 +695,7 @@ void RowGroup::InitializeAppend(RowGroupAppendState &append_state) {
 	append_state.row_group = this;
 	append_state.offset_in_row_group = this->count;
 	// for each column, initialize the append state
-	append_state.states = unique_ptr<ColumnAppendState[]>(new ColumnAppendState[GetColumnCount()]);
+	append_state.states = make_unsafe_array<ColumnAppendState>(GetColumnCount());
 	for (idx_t i = 0; i < GetColumnCount(); i++) {
 		auto &col_data = GetColumn(i);
 		col_data.InitializeAppend(append_state.states[i]);

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -1042,8 +1042,9 @@ static idx_t SortSelectionVector(SelectionVector &sel, idx_t count, row_t *ids)
 	return pos;
 }
 
-UpdateInfo *CreateEmptyUpdateInfo(TransactionData transaction, idx_t type_size, idx_t count, unique_ptr<char[]> &data) {
-	data = unique_ptr<char[]>(new char[sizeof(UpdateInfo) + (sizeof(sel_t) + type_size) * STANDARD_VECTOR_SIZE]);
+UpdateInfo *CreateEmptyUpdateInfo(TransactionData transaction, idx_t type_size, idx_t count,
+                                  unsafe_array_ptr<char> &data) {
+	data = make_unsafe_array<char>(sizeof(UpdateInfo) + (sizeof(sel_t) + type_size) * STANDARD_VECTOR_SIZE);
 	auto update_info = (UpdateInfo *)data.get();
 	update_info->max = STANDARD_VECTOR_SIZE;
 	update_info->tuples = (sel_t *)(((data_ptr_t)update_info) + sizeof(UpdateInfo));
@@ -1109,7 +1110,7 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 			}
 			node = node->next;
 		}
-		unique_ptr<char[]> update_info_data;
+		unsafe_array_ptr<char> update_info_data;
 		if (!node) {
 			// no updates made yet by this transaction: initially the update info to empty
 			if (transaction.transaction) {
@@ -1144,8 +1145,8 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 		auto result = make_uniq<UpdateNodeData>();
 
 		result->info = make_uniq<UpdateInfo>();
-		result->tuples = unique_ptr<sel_t[]>(new sel_t[STANDARD_VECTOR_SIZE]);
-		result->tuple_data = unique_ptr<data_t[]>(new data_t[STANDARD_VECTOR_SIZE * type_size]);
+		result->tuples = make_unsafe_array<sel_t>(STANDARD_VECTOR_SIZE);
+		result->tuple_data = make_unsafe_array<data_t>(STANDARD_VECTOR_SIZE * type_size);
 		result->info->tuples = result->tuples.get();
 		result->info->tuple_data = result->tuple_data.get();
 		result->info->version_number = TRANSACTION_ID_START - 1;
@@ -1153,7 +1154,7 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 		InitializeUpdateInfo(*result->info, ids, sel, count, vector_index, vector_offset);
 
 		// now create the transaction level update info in the undo log
-		unique_ptr<char[]> update_info_data;
+		unsafe_array_ptr<char> update_info_data;
 		UpdateInfo *transaction_node;
 		if (transaction.transaction) {
 			transaction_node = transaction.transaction->CreateUpdateInfo(type_size, count);

package/src/duckdb/third_party/fsst/libfsst.cpp

@@ -381,8 +381,7 @@ static inline size_t compressBulk(SymbolTable &symbolTable, size_t nlines, size_
 	size_t curLine, suffixLim = symbolTable.suffixLim;
 	u8 byteLim = symbolTable.nSymbols + symbolTable.zeroTerminated - symbolTable.lenHisto[0];
 
-	u8 buf[512+7]; /* +7 sentinel is to avoid 8-byte unaligned-loads going beyond 511 out-of-bounds */
-	memset(buf+511, 0, 8); /* and initialize the sentinal bytes */
+	u8 buf[512+7] = {}; /* +7 sentinel is to avoid 8-byte unaligned-loads going beyond 511 out-of-bounds */
 
 	// three variants are possible. dead code falls away since the bool arguments are constants
 	auto compressVariant = [&](bool noSuffixOpt, bool avoidBranch) {

package/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp

@@ -814,4 +814,13 @@ typedef enum PGOnConflictActionAlias {
 	PG_ONCONFLICT_ALIAS_IGNORE   /* INSERT OR IGNORE */
 } PGOnConflictActionAlias;
 
+/*
+ * PGInsertByNameOrPosition
+ *    "INSERT BY [POSITION|NAME]
+ */
+typedef enum PGInsertColumnOrder {
+	PG_INSERT_BY_POSITION,    /* INSERT BY POSITION (default behavior) */
+	PG_INSERT_BY_NAME,        /* INSERT BY NAME */
+} PGInsertColumnOrder;
+
 }

package/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp

@@ -1045,11 +1045,11 @@ typedef struct PGInferClause {
  */
 typedef struct PGOnConflictClause {
 	PGNodeTag type;
-	PGOnConflictAction action; /* DO NOTHING or UPDATE? */
-	PGInferClause *infer;      /* Optional index inference clause */
-	PGList *targetList;        /* the target list (of PGResTarget) */
-	PGNode *whereClause;       /* qualifications */
-	int location;              /* token location, or -1 if unknown */
+	PGOnConflictAction action;               /* DO NOTHING or UPDATE? */
+	PGInferClause *infer;                    /* Optional index inference clause */
+	PGList *targetList;                      /* the target list (of PGResTarget) */
+	PGNode *whereClause;                     /* qualifications */
+	int location;                            /* token location, or -1 if unknown */
 } PGOnConflictClause;
 
 /*
@@ -1125,14 +1125,15 @@ typedef struct PGRawStmt {
  */
 typedef struct PGInsertStmt {
 	PGNodeTag type;
-	PGRangeVar *relation;                 /* relation to insert into */
-	PGList *cols;                         /* optional: names of the target columns */
-	PGNode *selectStmt;                   /* the source SELECT/VALUES, or NULL */
+	PGRangeVar *relation;                    /* relation to insert into */
+	PGList *cols;                            /* optional: names of the target columns */
+	PGNode *selectStmt;                      /* the source SELECT/VALUES, or NULL */
 	PGOnConflictActionAlias onConflictAlias; /* the (optional) shorthand provided for the onConflictClause */
-	PGOnConflictClause *onConflictClause; /* ON CONFLICT clause */
-	PGList *returningList;                /* list of expressions to return */
-	PGWithClause *withClause;             /* WITH clause */
-	PGOverridingKind override;            /* OVERRIDING clause */
+	PGOnConflictClause *onConflictClause;    /* ON CONFLICT clause */
+	PGList *returningList;                   /* list of expressions to return */
+	PGWithClause *withClause;                /* WITH clause */
+	PGOverridingKind override;               /* OVERRIDING clause */
+	PGInsertColumnOrder insert_column_order; /* INSERT BY NAME or INSERT BY POSITION */
 } PGInsertStmt;
 
 /* ----------------------

package/src/duckdb/third_party/libpg_query/include/parser/gram.hpp

@@ -1065,9 +1065,10 @@ typedef union YYSTYPE
 	PGLockWaitPolicy lockwaitpolicy;
 	PGSubLinkType subquerytype;
 	PGViewCheckOption viewcheckoption;
+	PGInsertColumnOrder bynameorposition;
 }
 /* Line 1529 of yacc.c.  */
-#line 1071 "third_party/libpg_query/grammar/grammar_out.hpp"
+#line 1072 "third_party/libpg_query/grammar/grammar_out.hpp"
 	YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1