Format fix

awitten1 · Apr 19, 2024 · 8668a2f · 8668a2f
1 parent 4f7b3de
commit 8668a2f
Show file tree

Hide file tree

Showing 10 changed files with 43 additions and 27 deletions.
diff --git a/src/catalog/catalog_entry/duck_table_entry.cpp b/src/catalog/catalog_entry/duck_table_entry.cpp
@@ -76,7 +76,7 @@ vector<PhysicalIndex> GetUniqueConstraintKeys(const ColumnList &columns, const U
 	if (constraint.HasIndex()) {
 		indexes.push_back(columns.LogicalToPhysical(constraint.GetIndex()));
 	} else {
-		for(auto &keyname : constraint.GetColumnNames()) {
+		for (auto &keyname : constraint.GetColumnNames()) {
 			indexes.push_back(columns.GetColumn(keyname).Physical());
 		}
 	}
@@ -360,7 +360,7 @@ void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_i
                                                    const vector<LogicalIndex> &adjusted_indices,
                                                    const RemoveColumnInfo &info, CreateTableInfo &create_info,
                                                    const vector<unique_ptr<BoundConstraint>> &bound_constraints,
-												   bool is_generated) {
+                                                   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++) {
@@ -483,7 +483,8 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 	auto binder = Binder::CreateBinder(context);
 	auto bound_constraints = binder->BindConstraints(constraints, name, columns);
 
-	UpdateConstraintsOnColumnDrop(removed_index, adjusted_indices, info, *create_info, bound_constraints, dropped_column_is_generated);
+	UpdateConstraintsOnColumnDrop(removed_index, adjusted_indices, info, *create_info, bound_constraints,
+	                              dropped_column_is_generated);
 
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 	if (columns.GetColumn(LogicalIndex(removed_index)).Generated()) {

diff --git a/src/catalog/catalog_entry/table_catalog_entry.cpp b/src/catalog/catalog_entry/table_catalog_entry.cpp
@@ -234,8 +234,8 @@ vector<ColumnSegmentInfo> TableCatalogEntry::GetColumnSegmentInfo() {
 	return {};
 }
 
-void TableCatalogEntry::BindUpdateConstraints(Binder &binder, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
-                                              ClientContext &context) {
+void TableCatalogEntry::BindUpdateConstraints(Binder &binder, LogicalGet &get, LogicalProjection &proj,
+                                              LogicalUpdate &update, ClientContext &context) {
 	// check the constraints and indexes of the table to see if we need to project any additional columns
 	// we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
 	// suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint

diff --git a/src/execution/operator/persistent/physical_insert.cpp b/src/execution/operator/persistent/physical_insert.cpp
@@ -108,7 +108,8 @@ class InsertLocalState : public LocalSinkState {
 	idx_t update_count = 0;
 	unique_ptr<ConstraintVerificationState> constraint_state;
 
-	ConstraintVerificationState &GetConstraintState(DataTable &table, TableCatalogEntry &tableref, ClientContext &context) {
+	ConstraintVerificationState &GetConstraintState(DataTable &table, TableCatalogEntry &tableref,
+	                                                ClientContext &context) {
 		if (!constraint_state) {
 			constraint_state = table.InitializeConstraintVerification(tableref, context);
 		}

diff --git a/src/function/table/system/duckdb_constraints.cpp b/src/function/table/system/duckdb_constraints.cpp
@@ -132,7 +132,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &contex
 		});
 
 		sort(entries.begin(), entries.end(), [&](CatalogEntry &x, CatalogEntry &y) { return (x.name < y.name); });
-		for(auto &entry : entries) {
+		for (auto &entry : entries) {
 			result->entries.emplace_back(context, entry.get().Cast<TableCatalogEntry>());
 		}
 	};

diff --git a/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp b/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp
@@ -58,7 +58,8 @@ class DuckTableEntry : public TableCatalogEntry {
 	unique_ptr<CatalogEntry> SetColumnComment(ClientContext &context, SetColumnCommentInfo &info);
 
 	void UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index, const vector<LogicalIndex> &adjusted_indices,
-	                                   const RemoveColumnInfo &info, CreateTableInfo &create_info, const vector<unique_ptr<BoundConstraint>> &bound_constraints, bool is_generated);
+	                                   const RemoveColumnInfo &info, CreateTableInfo &create_info,
+	                                   const vector<unique_ptr<BoundConstraint>> &bound_constraints, bool is_generated);
 
 private:
 	//! A reference to the underlying storage unit used for this table

diff --git a/src/include/duckdb/planner/binder.hpp b/src/include/duckdb/planner/binder.hpp
@@ -122,9 +122,13 @@ class Binder : public std::enable_shared_from_this<Binder> {
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema);
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema,
 	                                                     vector<unique_ptr<Expression>> &bound_defaults);
-	static vector<unique_ptr<BoundConstraint>> BindConstraints(ClientContext &context, const vector<unique_ptr<Constraint>> &constraints, const string &table_name, const ColumnList &columns);
-	vector<unique_ptr<BoundConstraint>> BindConstraints(const vector<unique_ptr<Constraint>> &constraints, const string &table_name, const ColumnList &columns);
-	vector<unique_ptr<BoundConstraint>> BindNewConstraints(vector<unique_ptr<Constraint>> &constraints, const string &table_name, const ColumnList &columns);
+	static vector<unique_ptr<BoundConstraint>> BindConstraints(ClientContext &context,
+	                                                           const vector<unique_ptr<Constraint>> &constraints,
+	                                                           const string &table_name, const ColumnList &columns);
+	vector<unique_ptr<BoundConstraint>> BindConstraints(const vector<unique_ptr<Constraint>> &constraints,
+	                                                    const string &table_name, const ColumnList &columns);
+	vector<unique_ptr<BoundConstraint>> BindNewConstraints(vector<unique_ptr<Constraint>> &constraints,
+	                                                       const string &table_name, const ColumnList &columns);
 
 	void BindCreateViewInfo(CreateViewInfo &base);
 	SchemaCatalogEntry &BindSchema(CreateInfo &info);

diff --git a/src/include/duckdb/storage/data_table.hpp b/src/include/duckdb/storage/data_table.hpp
@@ -115,7 +115,6 @@ class DataTable {
 	//! Delete the entries with the specified row identifier from the table
 	idx_t Delete(TableDeleteState &state, ClientContext &context, Vector &row_ids, idx_t count);
 
-
 	unique_ptr<TableUpdateState> InitializeUpdate(TableCatalogEntry &table, ClientContext &context);
 	//! Update the entries with the specified row identifier from the table
 	void Update(TableUpdateState &state, ClientContext &context, Vector &row_ids,
@@ -194,14 +193,15 @@ class DataTable {
 	bool IndexNameIsUnique(const string &name);
 
 	//! Initialize constraint verification
-	unique_ptr<ConstraintVerificationState> InitializeConstraintVerification(TableCatalogEntry &table, ClientContext &context);
+	unique_ptr<ConstraintVerificationState> InitializeConstraintVerification(TableCatalogEntry &table,
+	                                                                         ClientContext &context);
 	//! Verify constraints with a chunk from the Append containing all columns of the table
 	void VerifyAppendConstraints(ConstraintVerificationState &state, ClientContext &context, DataChunk &chunk,
-								 optional_ptr<ConflictManager> conflict_manager = nullptr);
+	                             optional_ptr<ConflictManager> conflict_manager = nullptr);
 
 public:
 	static void VerifyUniqueIndexes(TableIndexList &indexes, ClientContext &context, DataChunk &chunk,
-									optional_ptr<ConflictManager> conflict_manager);
+	                                optional_ptr<ConflictManager> conflict_manager);
 
 private:
 	//! Verify the new added constraints against current persistent&local data

diff --git a/src/include/duckdb/storage/table/append_state.hpp b/src/include/duckdb/storage/table/append_state.hpp
@@ -71,7 +71,8 @@ struct TableAppendState {
 };
 
 struct ConstraintVerificationState {
-	explicit ConstraintVerificationState(TableCatalogEntry &table_p) : table(table_p) {}
+	explicit ConstraintVerificationState(TableCatalogEntry &table_p) : table(table_p) {
+	}
 
 	TableCatalogEntry &table;
 	vector<unique_ptr<BoundConstraint>> bound_constraints;

diff --git a/src/planner/binder/statement/bind_create_table.cpp b/src/planner/binder/statement/bind_create_table.cpp
@@ -35,7 +35,8 @@ static void CreateColumnDependencyManager(BoundCreateTableInfo &info) {
 	}
 }
 
-static unique_ptr<BoundConstraint> BindCheckConstraint(Binder &binder, const string &table_name, const ColumnList &columns, const unique_ptr<Constraint> &cond) {
+static unique_ptr<BoundConstraint> BindCheckConstraint(Binder &binder, const string &table_name,
+                                                       const ColumnList &columns, const unique_ptr<Constraint> &cond) {
 	auto bound_constraint = make_uniq<BoundCheckConstraint>();
 	// check constraint: bind the expression
 	CheckBinder check_binder(binder, binder.context, table_name, columns, bound_constraint->bound_columns);
@@ -47,12 +48,15 @@ static unique_ptr<BoundConstraint> BindCheckConstraint(Binder &binder, const str
 	return std::move(bound_constraint);
 }
 
-vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(ClientContext &context, const vector<unique_ptr<Constraint>> &constraints, const string &table_name, const ColumnList &columns) {
+vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(ClientContext &context,
+                                                            const vector<unique_ptr<Constraint>> &constraints,
+                                                            const string &table_name, const ColumnList &columns) {
 	auto binder = Binder::CreateBinder(context);
 	return binder->BindConstraints(constraints, table_name, columns);
 }
 
-vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(const vector<unique_ptr<Constraint>> &constraints, const string &table_name, const ColumnList &columns) {
+vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(const vector<unique_ptr<Constraint>> &constraints,
+                                                            const string &table_name, const ColumnList &columns) {
 	vector<unique_ptr<BoundConstraint>> bound_constraints;
 	for (auto &constr : constraints) {
 		switch (constr->type) {
@@ -128,16 +132,17 @@ vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(const vector<unique_
 	return bound_constraints;
 }
 
-vector<unique_ptr<BoundConstraint>> Binder::BindNewConstraints(vector<unique_ptr<Constraint>> &constraints, const string &table_name, const ColumnList &columns) {
+vector<unique_ptr<BoundConstraint>> Binder::BindNewConstraints(vector<unique_ptr<Constraint>> &constraints,
+                                                               const string &table_name, const ColumnList &columns) {
 	auto bound_constraints = BindConstraints(constraints, table_name, columns);
 
 	// handle primary keys/not null constraints
 	bool has_primary_key = false;
 	logical_index_set_t not_null_columns;
 	vector<LogicalIndex> primary_keys;
-	for(idx_t c = 0; c < constraints.size(); c++) {
+	for (idx_t c = 0; c < constraints.size(); c++) {
 		auto &constr = constraints[c];
-		switch(constr->type) {
+		switch (constr->type) {
 		case ConstraintType::NOT_NULL: {
 			auto &not_null = constr->Cast<NotNullConstraint>();
 			auto &col = columns.GetColumn(LogicalIndex(not_null.index));
@@ -263,7 +268,8 @@ static void ExtractExpressionDependencies(Expression &expr, LogicalDependencyLis
 	    expr, [&](Expression &child) { ExtractExpressionDependencies(child, dependencies); });
 }
 
-static void ExtractDependencies(BoundCreateTableInfo &info, vector<unique_ptr<Expression>> &defaults, vector<unique_ptr<BoundConstraint>> &constraints) {
+static void ExtractDependencies(BoundCreateTableInfo &info, vector<unique_ptr<Expression>> &defaults,
+                                vector<unique_ptr<BoundConstraint>> &constraints) {
 	for (auto &default_value : defaults) {
 		if (default_value) {
 			ExtractExpressionDependencies(*default_value, info.dependencies);

diff --git a/src/storage/data_table.cpp b/src/storage/data_table.cpp
@@ -617,7 +617,7 @@ void DataTable::VerifyUniqueIndexes(TableIndexList &indexes, ClientContext &cont
 }
 
 void DataTable::VerifyAppendConstraints(ConstraintVerificationState &state, ClientContext &context, DataChunk &chunk,
-										optional_ptr<ConflictManager> conflict_manager) {
+                                        optional_ptr<ConflictManager> conflict_manager) {
 	auto &table = state.table;
 	if (table.HasGeneratedColumns()) {
 		// Verify that the generated columns expression work with the inserted values
@@ -675,7 +675,8 @@ void DataTable::VerifyAppendConstraints(ConstraintVerificationState &state, Clie
 	}
 }
 
-unique_ptr<ConstraintVerificationState> DataTable::InitializeConstraintVerification(TableCatalogEntry &table, ClientContext &context) {
+unique_ptr<ConstraintVerificationState> DataTable::InitializeConstraintVerification(TableCatalogEntry &table,
+                                                                                    ClientContext &context) {
 	auto result = make_uniq<ConstraintVerificationState>(table);
 	auto binder = Binder::CreateBinder(context);
 	result->bound_constraints = binder->BindConstraints(table.GetConstraints(), table.name, table.GetColumns());
@@ -1063,7 +1064,8 @@ idx_t DataTable::Delete(TableDeleteState &state, ClientContext &context, Vector
 			if (state.has_delete_constraints) {
 				// perform the constraint verification
 				ColumnFetchState fetch_state;
-				local_storage.FetchChunk(*this, offset_ids, current_count, state.col_ids, state.verify_chunk, fetch_state);
+				local_storage.FetchChunk(*this, offset_ids, current_count, state.col_ids, state.verify_chunk,
+				                         fetch_state);
 				VerifyDeleteConstraints(state, context, state.verify_chunk);
 			}
 			delete_count += local_storage.Delete(*this, offset_ids, current_count);
@@ -1118,7 +1120,7 @@ static bool CreateMockChunk(TableCatalogEntry &table, const vector<PhysicalIndex
 	return true;
 }
 
-void DataTable::VerifyUpdateConstraints(ConstraintVerificationState &state,	ClientContext &context, DataChunk &chunk,
+void DataTable::VerifyUpdateConstraints(ConstraintVerificationState &state, ClientContext &context, DataChunk &chunk,
                                         const vector<PhysicalIndex> &column_ids) {
 	auto &table = state.table;
 	auto &constraints = table.GetConstraints();