duckdb 0.6.2-dev2085.0 → 0.6.2-dev2094.0

package/package.json

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

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

@@ -211,6 +211,19 @@ void ParquetWriter::SetSchemaProperties(const LogicalType &duckdb_type,
 	}
 }
 
+void VerifyUniqueNames(const vector<string> &names) {
+#ifdef DEBUG
+	unordered_set<string> name_set;
+	name_set.reserve(names.size());
+	for (auto &column : names) {
+		auto res = name_set.insert(column);
+		D_ASSERT(res.second == true);
+	}
+	// If there would be duplicates, these sizes would differ
+	D_ASSERT(name_set.size() == names.size());
+#endif
+}
+
 ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, FileOpener *file_opener_p, vector<LogicalType> types_p,
                              vector<string> names_p, CompressionCodec::type codec)
     : file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec) {
@@ -237,10 +250,13 @@ ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, FileOpener *fil
 	file_meta_data.schema[0].repetition_type = duckdb_parquet::format::FieldRepetitionType::REQUIRED;
 	file_meta_data.schema[0].__isset.repetition_type = true;
 
+	auto &unique_names = column_names;
+	VerifyUniqueNames(unique_names);
+
 	vector<string> schema_path;
 	for (idx_t i = 0; i < sql_types.size(); i++) {
 		column_writers.push_back(ColumnWriter::CreateWriterRecursive(file_meta_data.schema, *this, sql_types[i],
-		                                                             column_names[i], schema_path));
+		                                                             unique_names[i], schema_path));
 	}
 }
 

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

@@ -300,37 +300,13 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddCo
 	return make_unique<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), new_storage);
 }
 
-unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, RemoveColumnInfo &info) {
-	auto removed_index = GetColumnIndex(info.removed_column, info.if_column_exists);
-	if (!removed_index.IsValid()) {
-		if (!info.if_column_exists) {
-			throw CatalogException("Cannot drop column: rowid column cannot be dropped");
-		}
-		return nullptr;
-	}
-
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-
-	logical_index_set_t removed_columns;
-	if (column_dependency_manager.HasDependents(removed_index)) {
-		removed_columns = column_dependency_manager.GetDependents(removed_index);
-	}
-	if (!removed_columns.empty() && !info.cascade) {
-		throw CatalogException("Cannot drop column: column is a dependency of 1 or more generated column(s)");
-	}
-	for (auto &col : columns.Logical()) {
-		if (col.Logical() == removed_index || removed_columns.count(col.Logical())) {
-			continue;
-		}
-		create_info->columns.AddColumn(col.Copy());
-	}
-	if (create_info->columns.empty()) {
-		throw CatalogException("Cannot drop column: table only has one column remaining!");
-	}
-	auto adjusted_indices = column_dependency_manager.RemoveColumn(removed_index, columns.LogicalColumnCount());
+void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index,
+                                                   const vector<LogicalIndex> &adjusted_indices,
+                                                   const RemoveColumnInfo &info, CreateTableInfo &create_info,
+                                                   bool is_generated) {
 	// handle constraints for the new table
 	D_ASSERT(constraints.size() == bound_constraints.size());
+
 	for (idx_t constr_idx = 0; constr_idx < constraints.size(); constr_idx++) {
 		auto &constraint = constraints[constr_idx];
 		auto &bound_constraint = bound_constraints[constr_idx];
@@ -342,14 +318,20 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 				// the constraint is not about this column: we need to copy it
 				// we might need to shift the index back by one though, to account for the removed column
 				auto new_index = adjusted_indices[not_null_index.index];
-				create_info->constraints.push_back(make_unique<NotNullConstraint>(new_index));
+				create_info.constraints.push_back(make_unique<NotNullConstraint>(new_index));
 			}
 			break;
 		}
 		case ConstraintType::CHECK: {
+			// Generated columns can not be part of an index
 			// CHECK constraint
 			auto &bound_check = (BoundCheckConstraint &)*bound_constraint;
 			// check if the removed column is part of the check constraint
+			if (is_generated) {
+				// generated columns can not be referenced by constraints, we can just add the constraint back
+				create_info.constraints.push_back(constraint->Copy());
+				break;
+			}
 			auto physical_index = columns.LogicalToPhysical(removed_index);
 			if (bound_check.bound_columns.find(physical_index) != bound_check.bound_columns.end()) {
 				if (bound_check.bound_columns.size() > 1) {
@@ -362,7 +344,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 				}
 			} else {
 				// check constraint does not concern the removed column: simply re-add it
-				create_info->constraints.push_back(constraint->Copy());
+				create_info.constraints.push_back(constraint->Copy());
 			}
 			break;
 		}
@@ -377,7 +359,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 				}
 				unique.index = adjusted_indices[unique.index.index];
 			}
-			create_info->constraints.push_back(std::move(copy));
+			create_info.constraints.push_back(std::move(copy));
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {
@@ -398,13 +380,50 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 					    info.removed_column);
 				}
 			}
-			create_info->constraints.push_back(std::move(copy));
+			create_info.constraints.push_back(std::move(copy));
 			break;
 		}
 		default:
 			throw InternalException("Unsupported constraint for entry!");
 		}
 	}
+}
+
+unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, RemoveColumnInfo &info) {
+	auto removed_index = GetColumnIndex(info.removed_column, info.if_column_exists);
+	if (!removed_index.IsValid()) {
+		if (!info.if_column_exists) {
+			throw CatalogException("Cannot drop column: rowid column cannot be dropped");
+		}
+		return nullptr;
+	}
+
+	auto create_info = make_unique<CreateTableInfo>(schema, name);
+	create_info->temporary = temporary;
+
+	logical_index_set_t removed_columns;
+	if (column_dependency_manager.HasDependents(removed_index)) {
+		removed_columns = column_dependency_manager.GetDependents(removed_index);
+	}
+	if (!removed_columns.empty() && !info.cascade) {
+		throw CatalogException("Cannot drop column: column is a dependency of 1 or more generated column(s)");
+	}
+	bool dropped_column_is_generated = false;
+	for (auto &col : columns.Logical()) {
+		if (col.Logical() == removed_index || removed_columns.count(col.Logical())) {
+			if (col.Generated()) {
+				dropped_column_is_generated = true;
+			}
+			continue;
+		}
+		create_info->columns.AddColumn(col.Copy());
+	}
+	if (create_info->columns.empty()) {
+		throw CatalogException("Cannot drop column: table only has one column remaining!");
+	}
+	auto adjusted_indices = column_dependency_manager.RemoveColumn(removed_index, columns.LogicalColumnCount());
+
+	UpdateConstraintsOnColumnDrop(removed_index, adjusted_indices, info, *create_info, dropped_column_is_generated);
 
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev2085"
+#define DUCKDB_VERSION "0.6.2-dev2094"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "a038924fb3"
+#define DUCKDB_SOURCE_ID "4552228a14"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp

@@ -57,6 +57,9 @@ private:
 	unique_ptr<CatalogEntry> AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
 	unique_ptr<CatalogEntry> DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
 
+	void UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index, const vector<LogicalIndex> &adjusted_indices,
+	                                   const RemoveColumnInfo &info, CreateTableInfo &create_info, bool is_generated);
+
 private:
 	//! A reference to the underlying storage unit used for this table
 	std::shared_ptr<DataTable> storage;

package/src/duckdb/src/planner/binder/statement/bind_copy.cpp

@@ -33,6 +33,34 @@ static vector<idx_t> ColumnListToIndices(const vector<bool> &vec) {
 	return ret;
 }
 
+vector<string> GetUniqueNames(const vector<string> &original_names) {
+	unordered_set<string> name_set;
+	vector<string> unique_names;
+	unique_names.reserve(original_names.size());
+
+	for (auto &name : original_names) {
+		auto insert_result = name_set.insert(name);
+		if (insert_result.second == false) {
+			// Could not be inserted, name already exists
+			idx_t index = 1;
+			string postfixed_name;
+			while (true) {
+				postfixed_name = StringUtil::Format("%s:%d", name, index);
+				auto res = name_set.insert(postfixed_name);
+				if (!res.second) {
+					index++;
+					continue;
+				}
+				break;
+			}
+			unique_names.push_back(postfixed_name);
+		} else {
+			unique_names.push_back(name);
+		}
+	}
+	return unique_names;
+}
+
 BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	// COPY TO a file
 	auto &config = DBConfig::GetConfig(context);
@@ -99,8 +127,10 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 		use_tmp_file = is_file_and_exists && !per_thread_output && partition_cols.empty() && !is_stdout;
 	}
 
+	auto unique_column_names = GetUniqueNames(select_node.names);
+
 	auto function_data =
-	    copy_function->function.copy_to_bind(context, *stmt.info, select_node.names, select_node.types);
+	    copy_function->function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
 	// now create the copy information
 	auto copy = make_unique<LogicalCopyToFile>(copy_function->function, std::move(function_data));
 	copy->file_path = stmt.info->file_path;
@@ -110,7 +140,8 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	copy->per_thread_output = per_thread_output;
 	copy->partition_output = !partition_cols.empty();
 	copy->partition_columns = std::move(partition_cols);
-	copy->names = select_node.names;
+
+	copy->names = unique_column_names;
 	copy->expected_types = select_node.types;
 
 	copy->AddChild(std::move(select_node.plan));