duckdb 0.7.2-dev2699.0 → 0.7.2-dev2740.0

package/package.json

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

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

@@ -55,6 +55,30 @@ string PrintParquetElementToString(T &&entry) {
 	return ss.str();
 }
 
+template <class T>
+Value ParquetElementString(T &&value, bool is_set) {
+	if (!is_set) {
+		return Value();
+	}
+	return Value(ConvertParquetElementToString(value));
+}
+
+template <class T>
+Value ParquetElementInteger(T &&value, bool is_iset) {
+	if (!is_iset) {
+		return Value();
+	}
+	return Value::INTEGER(value);
+}
+
+template <class T>
+Value ParquetElementBigint(T &&value, bool is_iset) {
+	if (!is_iset) {
+		return Value();
+	}
+	return Value::BIGINT(value);
+}
+
 void ParquetMetaDataOperatorData::BindMetaData(vector<LogicalType> &return_types, vector<string> &names) {
 	names.emplace_back("file_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
@@ -186,7 +210,7 @@ void ParquetMetaDataOperatorData::LoadFileMetaData(ClientContext &context, const
 			current_chunk.SetValue(5, count, Value::BIGINT(col_idx));
 
 			// file_offset, LogicalType::BIGINT
-			current_chunk.SetValue(6, count, Value::BIGINT(column.file_offset));
+			current_chunk.SetValue(6, count, ParquetElementBigint(column.file_offset, row_group.__isset.file_offset));
 
 			// num_values, LogicalType::BIGINT
 			current_chunk.SetValue(7, count, Value::BIGINT(col_meta.num_values));
@@ -206,13 +230,10 @@ void ParquetMetaDataOperatorData::LoadFileMetaData(ClientContext &context, const
 			                       ConvertParquetStats(column_type, schema_element, stats.__isset.max, stats.max));
 
 			// stats_null_count, LogicalType::BIGINT
-			current_chunk.SetValue(
-			    12, count, stats.__isset.null_count ? Value::BIGINT(stats.null_count) : Value(LogicalType::BIGINT));
+			current_chunk.SetValue(12, count, ParquetElementBigint(stats.null_count, stats.__isset.null_count));
 
 			// stats_distinct_count, LogicalType::BIGINT
-			current_chunk.SetValue(13, count,
-			                       stats.__isset.distinct_count ? Value::BIGINT(stats.distinct_count)
-			                                                    : Value(LogicalType::BIGINT));
+			current_chunk.SetValue(13, count, ParquetElementBigint(stats.distinct_count, stats.__isset.distinct_count));
 
 			// stats_min_value, LogicalType::VARCHAR
 			current_chunk.SetValue(
@@ -234,10 +255,13 @@ void ParquetMetaDataOperatorData::LoadFileMetaData(ClientContext &context, const
 			current_chunk.SetValue(17, count, Value(StringUtil::Join(encoding_string, ", ")));
 
 			// index_page_offset, LogicalType::BIGINT
-			current_chunk.SetValue(18, count, Value::BIGINT(col_meta.index_page_offset));
+			current_chunk.SetValue(
+			    18, count, ParquetElementBigint(col_meta.index_page_offset, col_meta.__isset.index_page_offset));
 
 			// dictionary_page_offset, LogicalType::BIGINT
-			current_chunk.SetValue(19, count, Value::BIGINT(col_meta.dictionary_page_offset));
+			current_chunk.SetValue(
+			    19, count,
+			    ParquetElementBigint(col_meta.dictionary_page_offset, col_meta.__isset.dictionary_page_offset));
 
 			// data_page_offset, LogicalType::BIGINT
 			current_chunk.SetValue(20, count, Value::BIGINT(col_meta.data_page_offset));
@@ -299,8 +323,10 @@ void ParquetMetaDataOperatorData::BindSchema(vector<LogicalType> &return_types,
 	return_types.emplace_back(LogicalType::VARCHAR);
 }
 
-Value ParquetLogicalTypeToString(const duckdb_parquet::format::LogicalType &type) {
-
+Value ParquetLogicalTypeToString(const duckdb_parquet::format::LogicalType &type, bool is_set) {
+	if (!is_set) {
+		return Value();
+	}
 	if (type.__isset.STRING) {
 		return Value(PrintParquetElementToString(type.STRING));
 	}
@@ -362,31 +388,31 @@ void ParquetMetaDataOperatorData::LoadSchemaData(ClientContext &context, const v
 		current_chunk.SetValue(1, count, column.name);
 
 		// type, LogicalType::VARCHAR
-		current_chunk.SetValue(2, count, ConvertParquetElementToString(column.type));
+		current_chunk.SetValue(2, count, ParquetElementString(column.type, column.__isset.type));
 
-		// type_length, LogicalType::VARCHAR
-		current_chunk.SetValue(3, count, Value::INTEGER(column.type_length));
+		// type_length, LogicalType::INTEGER
+		current_chunk.SetValue(3, count, ParquetElementInteger(column.type_length, column.__isset.type_length));
 
 		// repetition_type, LogicalType::VARCHAR
-		current_chunk.SetValue(4, count, ConvertParquetElementToString(column.repetition_type));
+		current_chunk.SetValue(4, count, ParquetElementString(column.repetition_type, column.__isset.repetition_type));
 
 		// num_children, LogicalType::BIGINT
-		current_chunk.SetValue(5, count, Value::BIGINT(column.num_children));
+		current_chunk.SetValue(5, count, ParquetElementBigint(column.num_children, column.__isset.num_children));
 
 		// converted_type, LogicalType::VARCHAR
-		current_chunk.SetValue(6, count, ConvertParquetElementToString(column.converted_type));
+		current_chunk.SetValue(6, count, ParquetElementString(column.converted_type, column.__isset.converted_type));
 
 		// scale, LogicalType::BIGINT
-		current_chunk.SetValue(7, count, Value::BIGINT(column.scale));
+		current_chunk.SetValue(7, count, ParquetElementBigint(column.scale, column.__isset.scale));
 
 		// precision, LogicalType::BIGINT
-		current_chunk.SetValue(8, count, Value::BIGINT(column.precision));
+		current_chunk.SetValue(8, count, ParquetElementBigint(column.precision, column.__isset.precision));
 
 		// field_id, LogicalType::BIGINT
-		current_chunk.SetValue(9, count, Value::BIGINT(column.field_id));
+		current_chunk.SetValue(9, count, ParquetElementBigint(column.field_id, column.__isset.field_id));
 
 		// logical_type, LogicalType::VARCHAR
-		current_chunk.SetValue(10, count, ParquetLogicalTypeToString(column.logicalType));
+		current_chunk.SetValue(10, count, ParquetLogicalTypeToString(column.logicalType, column.__isset.logicalType));
 
 		count++;
 		if (count >= STANDARD_VECTOR_SIZE) {

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

@@ -55,6 +55,8 @@ void TableCatalogEntry::Serialize(Serializer &serializer) const {
 	D_ASSERT(!internal);
 
 	FieldWriter writer(serializer);
+	auto catalog_name = catalog.GetName();
+	writer.WriteString(catalog_name);
 	writer.WriteString(schema.name);
 	writer.WriteString(name);
 	columns.Serialize(writer);
@@ -66,6 +68,7 @@ unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source,
 	auto info = make_uniq<CreateTableInfo>();
 
 	FieldReader reader(source);
+	info->catalog = reader.ReadRequired<string>();
 	info->schema = reader.ReadRequired<string>();
 	info->table = reader.ReadRequired<string>();
 	info->columns = ColumnList::Deserialize(reader);

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -102,6 +102,7 @@ public:
 	optional_ptr<OptimisticDataWriter> writer;
 	// Rows that have been updated by a DO UPDATE conflict
 	unordered_set<row_t> updated_rows;
+	idx_t update_count = 0;
 };
 
 unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &context) const {
@@ -217,10 +218,10 @@ void PhysicalInsert::CombineExistingAndInsertTuples(DataChunk &result, DataChunk
 	result.SetCardinality(input_chunk.size());
 }
 
-void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
-                                             Vector &row_ids) const {
+idx_t PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
+                                              Vector &row_ids) const {
 	if (action_type == OnConflictAction::NOTHING) {
-		return;
+		return 0;
 	}
 
 	DataChunk update_chunk; // contains only the to-update columns
@@ -259,6 +260,7 @@ void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChun
 	auto &data_table = table.GetStorage();
 	// Perform the update, using the results of the SET expressions
 	data_table.Update(table, context.client, row_ids, set_columns, update_chunk);
+	return update_chunk.size();
 }
 
 // TODO: should we use a hash table to keep track of this instead?
@@ -275,12 +277,12 @@ void PhysicalInsert::RegisterUpdatedRows(InsertLocalState &lstate, const Vector
 	}
 }
 
-void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
-                                        InsertLocalState &lstate) const {
+idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
+                                         InsertLocalState &lstate) const {
 	auto &data_table = table.GetStorage();
 	if (action_type == OnConflictAction::THROW) {
 		data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, nullptr);
-		return;
+		return 0;
 	}
 	// Check whether any conflicts arise, and if they all meet the conflict_target + condition
 	// If that's not the case - We throw the first error
@@ -291,8 +293,8 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionConte
 	data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, &conflict_manager);
 	conflict_manager.Finalize();
 	if (conflict_manager.ConflictCount() == 0) {
-		// No conflicts found
-		return;
+		// No conflicts found, 0 updates performed
+		return 0;
 	}
 	auto &conflicts = conflict_manager.Conflicts();
 	auto &row_ids = conflict_manager.RowIds();
@@ -343,7 +345,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionConte
 
 	RegisterUpdatedRows(lstate, row_ids, combined_chunk.size());
 
-	PerformOnConflictAction(context, combined_chunk, table, row_ids);
+	idx_t updated_tuples = PerformOnConflictAction(context, combined_chunk, table, row_ids);
 
 	// Remove the conflicting tuples from the insert chunk
 	SelectionVector sel_vec(lstate.insert_chunk.size());
@@ -351,6 +353,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionConte
 	    SelectionVector::Inverted(conflicts.Selection(), sel_vec, conflicts.Count(), lstate.insert_chunk.size());
 	lstate.insert_chunk.Slice(sel_vec, new_size);
 	lstate.insert_chunk.SetCardinality(new_size);
+	return updated_tuples;
 }
 
 SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
@@ -368,13 +371,14 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			gstate.initialized = true;
 		}
 
-		OnConflictHandling(table, context, lstate);
+		idx_t updated_tuples = OnConflictHandling(table, context, lstate);
 		storage.LocalAppend(gstate.append_state, table, context.client, lstate.insert_chunk, true);
 
 		if (return_chunk) {
 			gstate.return_collection.Append(lstate.insert_chunk);
 		}
-		gstate.insert_count += chunk.size();
+		gstate.insert_count += lstate.insert_chunk.size();
+		gstate.insert_count += updated_tuples;
 	} else {
 		D_ASSERT(!return_chunk);
 		// parallel append
@@ -388,7 +392,8 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			lstate.local_collection->InitializeAppend(lstate.local_append_state);
 			lstate.writer = &gstate.table.GetStorage().CreateOptimisticWriter(context.client);
 		}
-		OnConflictHandling(table, context, lstate);
+		lstate.update_count += OnConflictHandling(table, context, lstate);
+
 		auto new_row_group = lstate.local_collection->Append(lstate.insert_chunk, lstate.local_append_state);
 		if (new_row_group) {
 			lstate.writer->CheckFlushToDisk(*lstate.local_collection);
@@ -421,6 +426,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 		// we have few rows - append to the local storage directly
 		lock_guard<mutex> lock(gstate.lock);
 		gstate.insert_count += append_count;
+		gstate.insert_count += lstate.update_count;
 		auto &table = gstate.table;
 		auto &storage = table.GetStorage();
 		storage.InitializeLocalAppend(gstate.append_state, context.client);
@@ -438,6 +444,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 
 		lock_guard<mutex> lock(gstate.lock);
 		gstate.insert_count += append_count;
+		gstate.insert_count += lstate.update_count;
 		gstate.table.GetStorage().LocalMerge(context.client, *lstate.local_collection);
 	}
 }

package/src/duckdb/src/function/table/range.cpp

@@ -273,6 +273,7 @@ void BuiltinFunctions::RegisterTableFunctions() {
 	RepeatTableFunction::RegisterFunction(*this);
 	SummaryTableFunction::RegisterFunction(*this);
 	UnnestTableFunction::RegisterFunction(*this);
+	RepeatRowTableFunction::RegisterFunction(*this);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/table/repeat_row.cpp

@@ -0,0 +1,60 @@
+#include "duckdb/function/table/range.hpp"
+#include "duckdb/common/algorithm.hpp"
+
+namespace duckdb {
+
+struct RepeatRowFunctionData : public TableFunctionData {
+	RepeatRowFunctionData(vector<Value> values, idx_t target_count)
+	    : values(std::move(values)), target_count(target_count) {
+	}
+
+	const vector<Value> values;
+	idx_t target_count;
+};
+
+struct RepeatRowOperatorData : public GlobalTableFunctionState {
+	RepeatRowOperatorData() : current_count(0) {
+	}
+	idx_t current_count;
+};
+
+static unique_ptr<FunctionData> RepeatRowBind(ClientContext &context, TableFunctionBindInput &input,
+                                              vector<LogicalType> &return_types, vector<string> &names) {
+	auto &inputs = input.inputs;
+	for (idx_t input_idx = 0; input_idx < inputs.size(); input_idx++) {
+		return_types.push_back(inputs[input_idx].type());
+		names.push_back("column" + std::to_string(input_idx));
+	}
+	return make_uniq<RepeatRowFunctionData>(inputs, input.named_parameters["num_rows"].GetValue<int64_t>());
+}
+
+static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context, TableFunctionInitInput &input) {
+	return make_uniq<RepeatRowOperatorData>();
+}
+
+static void RepeatRowFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (const RepeatRowFunctionData &)*data_p.bind_data;
+	auto &state = data_p.global_state->Cast<RepeatRowOperatorData>();
+
+	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
+	for (idx_t val_idx = 0; val_idx < bind_data.values.size(); val_idx++) {
+		output.data[val_idx].Reference(bind_data.values[val_idx]);
+	}
+	output.SetCardinality(remaining);
+	state.current_count += remaining;
+}
+
+static unique_ptr<NodeStatistics> RepeatRowCardinality(ClientContext &context, const FunctionData *bind_data_p) {
+	auto &bind_data = (const RepeatRowFunctionData &)*bind_data_p;
+	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
+}
+
+void RepeatRowTableFunction::RegisterFunction(BuiltinFunctions &set) {
+	TableFunction repeat_row("repeat_row", {}, RepeatRowFunction, RepeatRowBind, RepeatRowInit);
+	repeat_row.varargs = LogicalType::ANY;
+	repeat_row.named_parameters["num_rows"] = LogicalType::BIGINT;
+	repeat_row.cardinality = RepeatRowCardinality;
+	set.AddFunction(repeat_row);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev2699"
+#define DUCKDB_VERSION "0.7.2-dev2740"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "199c0211c7"
+#define DUCKDB_SOURCE_ID "bb37f3fd06"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp

@@ -116,9 +116,10 @@ public:
 protected:
 	void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_chunk, DataChunk &input_chunk,
 	                                    ClientContext &client) const;
-	void OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertLocalState &lstate) const;
-	void PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
-	                             Vector &row_ids) const;
+	//! Returns the amount of updated tuples
+	idx_t OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertLocalState &lstate) const;
+	idx_t PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
+	                              Vector &row_ids) const;
 	void RegisterUpdatedRows(InsertLocalState &lstate, const Vector &row_ids, idx_t count) const;
 };
 

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

@@ -29,6 +29,10 @@ struct RepeatTableFunction {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct RepeatRowTableFunction {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct UnnestTableFunction {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -257,10 +257,11 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 
 	// cast the parameters to the type of the function
 	for (idx_t i = 0; i < arguments.size(); i++) {
-		if (table_function.arguments[i] != LogicalType::ANY && table_function.arguments[i] != LogicalType::TABLE &&
-		    table_function.arguments[i] != LogicalType::POINTER &&
-		    table_function.arguments[i].id() != LogicalTypeId::LIST) {
-			parameters[i] = parameters[i].CastAs(context, table_function.arguments[i]);
+		auto target_type = i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs;
+
+		if (target_type != LogicalType::ANY && target_type != LogicalType::TABLE &&
+		    target_type != LogicalType::POINTER && target_type.id() != LogicalTypeId::LIST) {
+			parameters[i] = parameters[i].CastAs(context, target_type);
 		}
 	}
 

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

@@ -10,8 +10,7 @@ unique_ptr<LogicalOperator> LogicalCreate::Deserialize(LogicalDeserializationSta
 	auto &context = state.gstate.context;
 	auto info = CreateInfo::Deserialize(reader.GetSource());
 
-	auto schema_catalog_entry =
-	    Catalog::GetSchema(context, INVALID_CATALOG, info->schema, OnEntryNotFound::RETURN_NULL);
+	auto schema_catalog_entry = Catalog::GetSchema(context, info->catalog, info->schema, OnEntryNotFound::RETURN_NULL);
 	return make_uniq<LogicalCreate>(state.type, std::move(info), schema_catalog_entry);
 }
 

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

@@ -22,7 +22,7 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	auto catalog_info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
 
 	auto &table =
-	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, catalog_info->schema, catalog_info->table);
+	    Catalog::GetEntry<TableCatalogEntry>(context, catalog_info->catalog, catalog_info->schema, catalog_info->table);
 	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 
 	auto create_info = reader.ReadOptional<CreateInfo>(nullptr);

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

@@ -1,6 +1,7 @@
 #include "duckdb/planner/operator/logical_delete.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
+
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/create_table_info.hpp"
 
 namespace duckdb {
 
@@ -19,8 +20,7 @@ unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationSta
 	auto &context = state.gstate.context;
 	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
 
-	auto &table_catalog_entry =
-	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info->schema, info->table);
+	auto &table_catalog_entry = Catalog::GetEntry<TableCatalogEntry>(context, info->catalog, info->schema, info->table);
 
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);

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

@@ -41,7 +41,7 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 	auto bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	auto action_type = reader.ReadRequired<OnConflictAction>();
 
-	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
+	auto &catalog = Catalog::GetCatalog(context, info->catalog);
 
 	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
 	auto result = make_uniq<LogicalInsert>(table_catalog_entry, table_index);

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

@@ -21,7 +21,7 @@ void LogicalUpdate::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto &context = state.gstate.context;
 	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
-	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
+	auto &catalog = Catalog::GetCatalog(context, info->catalog);
 
 	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
 	auto result = make_uniq<LogicalUpdate>(table_catalog_entry);

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

@@ -5,46 +5,25 @@
 
 namespace duckdb {
 void BoundCreateTableInfo::Serialize(Serializer &serializer) const {
-	schema.Serialize(serializer);
 	serializer.WriteOptional(base);
-
-	// TODO[YLM]: Review if we want/need to serialize more of the fields.
-	//! The map of column names -> column index, used during binding
-	// case_insensitive_map_t<column_t> name_map;
-
-	//! Column dependency manager of the table
-	// ColumnDependencyManager column_dependency_manager;
-
 	serializer.WriteList(constraints);
 	serializer.WriteList(bound_constraints);
 	serializer.WriteList(bound_defaults);
-
-	//! Dependents of the table (in e.g. default values)
-	// unordered_set<CatalogEntry *> dependencies;
-
-	//! The existing table data on disk (if any)
-	// unique_ptr<PersistentTableData> data;
-
-	//! CREATE TABLE from QUERY
 	serializer.WriteOptional(query);
-
-	//! Indexes created by this table <Block_ID, Offset>
-	// vector<BlockPointer> indexes;
 }
 
 unique_ptr<BoundCreateTableInfo> BoundCreateTableInfo::Deserialize(Deserializer &source,
                                                                    PlanDeserializationState &state) {
-	auto &context = state.context;
-	auto create_info = SchemaCatalogEntry::Deserialize(source);
-	auto schema_name = create_info->schema;
-	auto &schema = Catalog::GetSchema(context, INVALID_CATALOG, schema_name);
-	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(create_info));
-	result->base = source.ReadOptional<CreateInfo>();
+	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;
 }

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

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

package/src/duckdb/ub_src_function_table.cpp

@@ -10,6 +10,8 @@
 
 #include "src/function/table/repeat.cpp"
 
+#include "src/function/table/repeat_row.cpp"
+
 #include "src/function/table/copy_csv.cpp"
 
 #include "src/function/table/read_csv.cpp"