duckdb 0.3.3-dev944.0 → 0.3.3-dev977.0

package/src/duckdb.cpp

@@ -1300,12 +1300,116 @@ public:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/constraints/bound_foreign_key_constraint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class BoundForeignKeyConstraint : public BoundConstraint {
+public:
+	BoundForeignKeyConstraint(ForeignKeyInfo info_p, unordered_set<idx_t> pk_key_set_p,
+	                          unordered_set<idx_t> fk_key_set_p)
+	    : BoundConstraint(ConstraintType::FOREIGN_KEY), info(move(info_p)), pk_key_set(move(pk_key_set_p)),
+	      fk_key_set(move(fk_key_set_p)) {
+#ifdef DEBUG
+		D_ASSERT(info.pk_keys.size() == pk_key_set.size());
+		for (auto &key : info.pk_keys) {
+			D_ASSERT(pk_key_set.find(key) != pk_key_set.end());
+		}
+		D_ASSERT(info.fk_keys.size() == fk_key_set.size());
+		for (auto &key : info.fk_keys) {
+			D_ASSERT(fk_key_set.find(key) != fk_key_set.end());
+		}
+#endif
+	}
+
+	ForeignKeyInfo info;
+	//! The same keys but stored as an unordered set
+	unordered_set<idx_t> pk_key_set;
+	//! The same keys but stored as an unordered set
+	unordered_set<idx_t> fk_key_set;
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/constraints/foreign_key_constraint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class ForeignKeyConstraint : public Constraint {
+public:
+	DUCKDB_API ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info);
+
+	//! The set of main key table's columns
+	vector<string> pk_columns;
+	//! The set of foreign key table's columns
+	vector<string> fk_columns;
+	ForeignKeyInfo info;
+
+public:
+	DUCKDB_API string ToString() const override;
+
+	DUCKDB_API unique_ptr<Constraint> Copy() const override;
+
+	//! Serialize to a stand-alone binary blob
+	DUCKDB_API void Serialize(FieldWriter &writer) const override;
+	//! Deserializes a ParsedConstraint
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+};
+
+} // namespace duckdb
+
 
 #include <algorithm>
 #include <sstream>
 
 namespace duckdb {
 
+void FindForeignKeyInformation(CatalogEntry *entry, AlterForeignKeyType alter_fk_type,
+                               vector<unique_ptr<AlterForeignKeyInfo>> &fk_arrays) {
+	if (entry->type != CatalogType::TABLE_ENTRY) {
+		return;
+	}
+	auto *table_entry = (TableCatalogEntry *)entry;
+	for (idx_t i = 0; i < table_entry->constraints.size(); i++) {
+		auto &cond = table_entry->constraints[i];
+		if (cond->type != ConstraintType::FOREIGN_KEY) {
+			continue;
+		}
+		auto &fk = (ForeignKeyConstraint &)*cond;
+		if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+			fk_arrays.push_back(make_unique<AlterForeignKeyInfo>(fk.info.schema, fk.info.table, entry->name,
+			                                                     fk.pk_columns, fk.fk_columns, fk.info.pk_keys,
+			                                                     fk.info.fk_keys, alter_fk_type));
+		} else if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE &&
+		           alter_fk_type == AlterForeignKeyType::AFT_DELETE) {
+			throw CatalogException("Could not drop the table because this table is main key table of the table \"%s\"",
+			                       fk.info.table);
+		}
+	}
+}
+
 SchemaCatalogEntry::SchemaCatalogEntry(Catalog *catalog, string name_p, bool internal)
     : CatalogEntry(CatalogType::SCHEMA_ENTRY, catalog, move(name_p)),
       tables(*catalog, make_unique<DefaultViewGenerator>(*catalog, this)), indexes(*catalog), table_functions(*catalog),
@@ -1371,7 +1475,23 @@ CatalogEntry *SchemaCatalogEntry::CreateType(ClientContext &context, CreateTypeI
 CatalogEntry *SchemaCatalogEntry::CreateTable(ClientContext &context, BoundCreateTableInfo *info) {
 	auto table = make_unique<TableCatalogEntry>(catalog, this, info);
 	table->storage->info->cardinality = table->storage->GetTotalRows();
-	return AddEntry(context, move(table), info->Base().on_conflict, info->dependencies);
+	CatalogEntry *entry = AddEntry(context, move(table), info->Base().on_conflict, info->dependencies);
+	if (!entry) {
+		return nullptr;
+	}
+	// add a foreign key constraint in main key table if there is a foreign key constraint
+	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
+	FindForeignKeyInformation(entry, AlterForeignKeyType::AFT_ADD, fk_arrays);
+	for (idx_t i = 0; i < fk_arrays.size(); i++) {
+		// alter primary key table
+		AlterForeignKeyInfo *fk_info = fk_arrays[i].get();
+		catalog->Alter(context, fk_info);
+
+		// make a dependency between this table and referenced table
+		auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
+		info->dependencies.insert(set.GetEntry(context, fk_info->name));
+	}
+	return entry;
 }
 
 CatalogEntry *SchemaCatalogEntry::CreateView(ClientContext &context, CreateViewInfo *info) {
@@ -1475,9 +1595,20 @@ void SchemaCatalogEntry::DropEntry(ClientContext &context, DropInfo *info) {
 		throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", info->name,
 		                       CatalogTypeToString(existing_entry->type), CatalogTypeToString(info->type));
 	}
+
+	// if there is a foreign key constraint, get that information
+	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
+	FindForeignKeyInformation(existing_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
+
 	if (!set.DropEntry(context, info->name, info->cascade)) {
 		throw InternalException("Could not drop element because of an internal error");
 	}
+
+	// remove the foreign key constraint in main key table if main key table's name is valid
+	for (idx_t i = 0; i < fk_arrays.size(); i++) {
+		// alter primary key tablee
+		Catalog::GetCatalog(context).Alter(context, fk_arrays[i].get());
+	}
 }
 
 void SchemaCatalogEntry::Alter(ClientContext &context, AlterInfo *info) {
@@ -1706,6 +1837,7 @@ public:
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1802,6 +1934,7 @@ public:
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -2497,10 +2630,16 @@ struct ARTIndexScanState : public IndexScanState {
 	idx_t result_index = 0;
 };
 
+enum VerifyExistenceType : uint8_t {
+	APPEND = 0,    // for purpose to append into table
+	APPEND_FK = 1, // for purpose to append into table has foreign key
+	DELETE_FK = 2  // for purpose to delete from table related to foreign key
+};
+
 class ART : public Index {
 public:
 	ART(const vector<column_t> &column_ids, const vector<unique_ptr<Expression>> &unbound_expressions,
-	    bool is_unique = false, bool is_primary = false);
+	    IndexConstraintType constraint_type);
 	~ART() override;
 
 	//! Root of the tree
@@ -2527,6 +2666,10 @@ public:
 	bool Append(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
 	//! Verify that data can be appended to the index
 	void VerifyAppend(DataChunk &chunk) override;
+	//! Verify that data can be appended to the index for foreign key constraint
+	void VerifyAppendForeignKey(DataChunk &chunk, string *err_msg_ptr) override;
+	//! Verify that data can be delete from the index for foreign key constraint
+	void VerifyDeleteForeignKey(DataChunk &chunk, string *err_msg_ptr) override;
 	//! Delete entries in the index
 	void Delete(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
 	//! Insert data into the index.
@@ -2571,6 +2714,8 @@ private:
 	                  vector<row_t> &result_ids);
 
 	void GenerateKeys(DataChunk &input, vector<unique_ptr<Key>> &keys);
+
+	void VerifyExistence(DataChunk &chunk, VerifyExistenceType verify_type, string *err_msg_ptr = NULL);
 };
 
 } // namespace duckdb
@@ -2672,6 +2817,27 @@ idx_t TableCatalogEntry::GetColumnIndex(string &column_name, bool if_exists) {
 	return idx_t(entry->second);
 }
 
+void AddDataTableIndex(DataTable *storage, vector<ColumnDefinition> &columns, vector<idx_t> &keys,
+                       IndexConstraintType constraint_type) {
+	// fetch types and create expressions for the index from the columns
+	vector<column_t> column_ids;
+	vector<unique_ptr<Expression>> unbound_expressions;
+	vector<unique_ptr<Expression>> bound_expressions;
+	idx_t key_nr = 0;
+	for (auto &key : keys) {
+		D_ASSERT(key < columns.size());
+
+		unbound_expressions.push_back(make_unique<BoundColumnRefExpression>(columns[key].name, columns[key].type,
+		                                                                    ColumnBinding(0, column_ids.size())));
+
+		bound_expressions.push_back(make_unique<BoundReferenceExpression>(columns[key].type, key_nr++));
+		column_ids.push_back(key);
+	}
+	// create an adaptive radix tree around the expressions
+	auto art = make_unique<ART>(column_ids, move(unbound_expressions), constraint_type);
+	storage->AddIndex(move(art), bound_expressions);
+}
+
 TableCatalogEntry::TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
                                      std::shared_ptr<DataTable> inherited_storage)
     : StandardEntry(CatalogType::TABLE_ENTRY, schema, catalog, info->Base().table), storage(move(inherited_storage)),
@@ -2695,29 +2861,24 @@ TableCatalogEntry::TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schem
 		}
 		storage = make_shared<DataTable>(catalog->db, schema->name, name, move(colum_def_copy), move(info->data));
 
-		// create the unique indexes for the UNIQUE and PRIMARY KEY constraints
+		// create the unique indexes for the UNIQUE and PRIMARY KEY and FOREIGN KEY constraints
 		for (idx_t i = 0; i < bound_constraints.size(); i++) {
 			auto &constraint = bound_constraints[i];
 			if (constraint->type == ConstraintType::UNIQUE) {
 				// unique constraint: create a unique index
 				auto &unique = (BoundUniqueConstraint &)*constraint;
-				// fetch types and create expressions for the index from the columns
-				vector<column_t> column_ids;
-				vector<unique_ptr<Expression>> unbound_expressions;
-				vector<unique_ptr<Expression>> bound_expressions;
-				idx_t key_nr = 0;
-				for (auto &key : unique.keys) {
-					D_ASSERT(key < columns.size());
-
-					unbound_expressions.push_back(make_unique<BoundColumnRefExpression>(
-					    columns[key].name, columns[key].type, ColumnBinding(0, column_ids.size())));
-
-					bound_expressions.push_back(make_unique<BoundReferenceExpression>(columns[key].type, key_nr++));
-					column_ids.push_back(key);
+				IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
+				if (unique.is_primary_key) {
+					constraint_type = IndexConstraintType::PRIMARY;
+				}
+				AddDataTableIndex(storage.get(), columns, unique.keys, constraint_type);
+			} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
+				// foreign key constraint: create a foreign key index
+				auto &bfk = (BoundForeignKeyConstraint &)*constraint;
+				if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
+				    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
+					AddDataTableIndex(storage.get(), columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
 				}
-				// create an adaptive radix tree around the expressions
-				auto art = make_unique<ART>(column_ids, move(unbound_expressions), true, unique.is_primary_key);
-				storage->AddIndex(move(art), bound_expressions);
 			}
 		}
 	}
@@ -2760,6 +2921,10 @@ unique_ptr<CatalogEntry> TableCatalogEntry::AlterEntry(ClientContext &context, A
 		auto change_type_info = (ChangeColumnTypeInfo *)table_info;
 		return ChangeColumnType(context, *change_type_info);
 	}
+	case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
+		auto foreign_key_constraint_info = (AlterForeignKeyInfo *)table_info;
+		return SetForeignKeyConstraint(context, *foreign_key_constraint_info);
+	}
 	default:
 		throw InternalException("Unrecognized alter table type!");
 	}
@@ -2810,6 +2975,26 @@ unique_ptr<CatalogEntry> TableCatalogEntry::RenameColumn(ClientContext &context,
 			}
 			break;
 		}
+		case ConstraintType::FOREIGN_KEY: {
+			// FOREIGN KEY constraint: possibly need to rename columns
+			auto &fk = (ForeignKeyConstraint &)*copy;
+			vector<string> columns = fk.pk_columns;
+			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+				columns = fk.fk_columns;
+			} else if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
+				for (idx_t i = 0; i < fk.fk_columns.size(); i++) {
+					columns.push_back(fk.fk_columns[i]);
+				}
+			}
+			for (idx_t i = 0; i < columns.size(); i++) {
+				if (columns[i] == info.old_name) {
+					throw CatalogException(
+					    "Cannot rename column \"%s\" because this is involved in the foreign key constraint",
+					    info.old_name);
+				}
+			}
+			break;
+		}
 		default:
 			throw InternalException("Unsupported constraint for entry!");
 		}
@@ -2906,6 +3091,27 @@ unique_ptr<CatalogEntry> TableCatalogEntry::RemoveColumn(ClientContext &context,
 			create_info->constraints.push_back(move(copy));
 			break;
 		}
+		case ConstraintType::FOREIGN_KEY: {
+			auto copy = constraint->Copy();
+			auto &fk = (ForeignKeyConstraint &)*copy;
+			vector<string> columns = fk.pk_columns;
+			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+				columns = fk.fk_columns;
+			} else if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
+				for (idx_t i = 0; i < fk.fk_columns.size(); i++) {
+					columns.push_back(fk.fk_columns[i]);
+				}
+			}
+			for (idx_t i = 0; i < columns.size(); i++) {
+				if (columns[i] == info.removed_column) {
+					throw CatalogException(
+					    "Cannot drop column \"%s\" because there is a FOREIGN KEY constraint that depends on it",
+					    info.removed_column);
+				}
+			}
+			create_info->constraints.push_back(move(copy));
+			break;
+		}
 		default:
 			throw InternalException("Unsupported constraint for entry!");
 		}
@@ -2981,6 +3187,21 @@ unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &cont
 			}
 			break;
 		}
+		case ConstraintType::FOREIGN_KEY: {
+			auto &bfk = (BoundForeignKeyConstraint &)*bound_constraints[i];
+			unordered_set<idx_t> key_set = bfk.pk_key_set;
+			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+				key_set = bfk.fk_key_set;
+			} else if (bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
+				for (idx_t i = 0; i < bfk.info.fk_keys.size(); i++) {
+					key_set.insert(bfk.info.fk_keys[i]);
+				}
+			}
+			if (key_set.find(change_idx) != key_set.end()) {
+				throw BinderException("Cannot change the type of a column that has a FOREIGN KEY constraint specified");
+			}
+			break;
+		}
 		default:
 			throw InternalException("Unsupported constraint for entry!");
 		}
@@ -3004,6 +3225,39 @@ unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &cont
 	                                      new_storage);
 }
 
+unique_ptr<CatalogEntry> TableCatalogEntry::SetForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info) {
+	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+
+	for (idx_t i = 0; i < columns.size(); i++) {
+		create_info->columns.push_back(columns[i].Copy());
+	}
+	for (idx_t i = 0; i < constraints.size(); i++) {
+		auto constraint = constraints[i]->Copy();
+		if (constraint->type == ConstraintType::FOREIGN_KEY) {
+			ForeignKeyConstraint &fk = (ForeignKeyConstraint &)*constraint;
+			if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && fk.info.table == info.fk_table) {
+				continue;
+			}
+		}
+		create_info->constraints.push_back(move(constraint));
+	}
+	if (info.type == AlterForeignKeyType::AFT_ADD) {
+		ForeignKeyInfo fk_info;
+		fk_info.type = ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE;
+		fk_info.schema = info.schema;
+		fk_info.table = info.fk_table;
+		fk_info.pk_keys = info.pk_keys;
+		fk_info.fk_keys = info.fk_keys;
+		create_info->constraints.push_back(
+		    make_unique<ForeignKeyConstraint>(info.pk_columns, info.fk_columns, move(fk_info)));
+	}
+
+	auto binder = Binder::CreateBinder(context);
+	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
+
+	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+}
+
 ColumnDefinition &TableCatalogEntry::GetColumn(const string &name) {
 	auto entry = name_map.find(name);
 	if (entry == name_map.end() || entry->second == COLUMN_IDENTIFIER_ROW_ID) {
@@ -3085,6 +3339,12 @@ string TableCatalogEntry::ToSQL() {
 				}
 				extra_constraints.push_back(constraint->ToString());
 			}
+		} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
+			auto &fk = (ForeignKeyConstraint &)*constraint;
+			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
+			    fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
+				extra_constraints.push_back(constraint->ToString());
+			}
 		} else {
 			extra_constraints.push_back(constraint->ToString());
 		}
@@ -48493,9 +48753,9 @@ ExpressionExecutorState::ExpressionExecutorState(const string &name) : profiler(
 
 namespace duckdb {
 
-ART::ART(const vector<column_t> &column_ids, const vector<unique_ptr<Expression>> &unbound_expressions, bool is_unique,
-         bool is_primary)
-    : Index(IndexType::ART, column_ids, unbound_expressions, is_unique, is_primary) {
+ART::ART(const vector<column_t> &column_ids, const vector<unique_ptr<Expression>> &unbound_expressions,
+         IndexConstraintType constraint_type)
+    : Index(IndexType::ART, column_ids, unbound_expressions, constraint_type) {
 	tree = nullptr;
 	expression_result.Initialize(logical_types);
 	is_little_endian = IsLittleEndian();
@@ -48749,43 +49009,19 @@ bool ART::Append(IndexLock &lock, DataChunk &appended_data, Vector &row_identifi
 }
 
 void ART::VerifyAppend(DataChunk &chunk) {
-	if (!is_unique) {
-		return;
-	}
-
-	DataChunk expression_result;
-	expression_result.Initialize(logical_types);
-
-	// unique index, check
-	lock_guard<mutex> l(lock);
-	// first resolve the expressions for the index
-	ExecuteExpressions(chunk, expression_result);
+	VerifyExistence(chunk, VerifyExistenceType::APPEND);
+}
 
-	// generate the keys for the given input
-	vector<unique_ptr<Key>> keys;
-	GenerateKeys(expression_result, keys);
+void ART::VerifyAppendForeignKey(DataChunk &chunk, string *err_msg_ptr) {
+	VerifyExistence(chunk, VerifyExistenceType::APPEND_FK, err_msg_ptr);
+}
 
-	for (idx_t i = 0; i < chunk.size(); i++) {
-		if (!keys[i]) {
-			continue;
-		}
-		if (Lookup(tree, *keys[i], 0) != nullptr) {
-			string key_name;
-			for (idx_t k = 0; k < expression_result.ColumnCount(); k++) {
-				if (k > 0) {
-					key_name += ", ";
-				}
-				key_name += unbound_expressions[k]->GetName() + ": " + expression_result.data[k].GetValue(i).ToString();
-			}
-			// node already exists in tree
-			throw ConstraintException("duplicate key \"%s\" violates %s constraint", key_name,
-			                          is_primary ? "primary key" : "unique");
-		}
-	}
+void ART::VerifyDeleteForeignKey(DataChunk &chunk, string *err_msg_ptr) {
+	VerifyExistence(chunk, VerifyExistenceType::DELETE_FK, err_msg_ptr);
 }
 
 bool ART::InsertToLeaf(Leaf &leaf, row_t row_id) {
-	if (is_unique && leaf.num_elements != 0) {
+	if (IsUnique() && leaf.num_elements != 0) {
 		return false;
 	}
 	leaf.Insert(row_id);
@@ -49360,6 +49596,70 @@ bool ART::Scan(Transaction &transaction, DataTable &table, IndexScanState &table
 	return true;
 }
 
+void ART::VerifyExistence(DataChunk &chunk, VerifyExistenceType verify_type, string *err_msg_ptr) {
+	if (verify_type != VerifyExistenceType::DELETE_FK && !IsUnique()) {
+		return;
+	}
+
+	DataChunk expression_result;
+	expression_result.Initialize(logical_types);
+
+	// unique index, check
+	lock_guard<mutex> l(lock);
+	// first resolve the expressions for the index
+	ExecuteExpressions(chunk, expression_result);
+
+	// generate the keys for the given input
+	vector<unique_ptr<Key>> keys;
+	GenerateKeys(expression_result, keys);
+
+	for (idx_t i = 0; i < chunk.size(); i++) {
+		if (!keys[i]) {
+			continue;
+		}
+		Node *node_ptr = Lookup(tree, *keys[i], 0);
+		bool throw_exception =
+		    verify_type == VerifyExistenceType::APPEND_FK ? node_ptr == nullptr : node_ptr != nullptr;
+		if (!throw_exception) {
+			continue;
+		}
+		string key_name;
+		for (idx_t k = 0; k < expression_result.ColumnCount(); k++) {
+			if (k > 0) {
+				key_name += ", ";
+			}
+			key_name += unbound_expressions[k]->GetName() + ": " + expression_result.data[k].GetValue(i).ToString();
+		}
+		string exception_msg;
+		switch (verify_type) {
+		case VerifyExistenceType::APPEND: {
+			// node already exists in tree
+			string type = IsPrimary() ? "primary key" : "unique";
+			exception_msg = "duplicate key \"" + key_name + "\" violates ";
+			exception_msg += type + " constraint";
+			break;
+		}
+		case VerifyExistenceType::APPEND_FK: {
+			// found node no exists in tree
+			exception_msg =
+			    "violates foreign key constraint because key \"" + key_name + "\" no exist in referenced table";
+			break;
+		}
+		case VerifyExistenceType::DELETE_FK: {
+			// found node exists in tree
+			exception_msg =
+			    "violates foreign key constraint because key \"" + key_name + "\" exist in table has foreign key";
+			break;
+		}
+		}
+		if (err_msg_ptr) {
+			err_msg_ptr[i] = exception_msg;
+		} else {
+			throw ConstraintException(exception_msg);
+		}
+	}
+}
+
 } // namespace duckdb
 
 
@@ -62180,19 +62480,16 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	vector<CatalogEntry *> views;
 	vector<CatalogEntry *> indexes;
 
-	Catalog::GetCatalog(ccontext).schemas->Scan(context.client, [&](CatalogEntry *entry) {
-		auto schema = (SchemaCatalogEntry *)entry;
+	auto schema_list = Catalog::GetCatalog(ccontext).schemas->GetEntries<SchemaCatalogEntry>(context.client);
+	for (auto &schema : schema_list) {
 		if (!schema->internal) {
-			// export schema
 			schemas.push_back(schema);
 		}
 		schema->Scan(context.client, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
 			if (entry->internal) {
 				return;
 			}
-			if (entry->type == CatalogType::TABLE_ENTRY) {
-				tables.push_back(entry);
-			} else {
+			if (entry->type != CatalogType::TABLE_ENTRY) {
 				views.push_back(entry);
 			}
 		});
@@ -62201,7 +62498,12 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 		schema->Scan(context.client, CatalogType::TYPE_ENTRY,
 		             [&](CatalogEntry *entry) { custom_types.push_back(entry); });
 		schema->Scan(context.client, CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) { indexes.push_back(entry); });
-	});
+	}
+
+	// consider the order of tables because of foreign key constraint
+	for (idx_t i = 0; i < exported_tables.data.size(); i++) {
+		tables.push_back((CatalogEntry *)exported_tables.data[i].entry);
+	}
 
 	// write the schema.sql file
 	// export order is SCHEMA -> SEQUENCE -> TABLE -> VIEW -> INDEX
@@ -62219,9 +62521,9 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	// write the load.sql file
 	// for every table, we write COPY INTO statement with the specified options
 	stringstream load_ss;
-	for (auto const &kv : exported_tables.data) {
-		auto table = kv.first;
-		auto exported_table_info = kv.second;
+	for (idx_t i = 0; i < exported_tables.data.size(); i++) {
+		auto &table = exported_tables.data[i].entry;
+		auto exported_table_info = exported_tables.data[i].table_data;
 		WriteCopyStatement(fs, load_ss, table, *info, exported_table_info, function);
 	}
 	WriteStringStreamToFile(fs, opener, load_ss, fs.JoinPath(info->file_path, "load.sql"));
@@ -63749,7 +64051,8 @@ void PhysicalCreateIndex::GetData(ExecutionContext &context, DataChunk &chunk, G
 	unique_ptr<Index> index;
 	switch (info->index_type) {
 	case IndexType::ART: {
-		index = make_unique<ART>(column_ids, unbound_expressions, info->unique);
+		index = make_unique<ART>(column_ids, unbound_expressions,
+		                         info->unique ? IndexConstraintType::UNIQUE : IndexConstraintType::NONE);
 		break;
 	}
 	default:
@@ -97600,6 +97903,7 @@ void DuckDBColumnsFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 struct DuckDBConstraintsData : public FunctionOperatorData {
@@ -97758,7 +98062,13 @@ void DuckDBConstraintsFunction(ClientContext &context, const FunctionData *bind_
 				column_index_list.push_back(bound_not_null.index);
 				break;
 			}
-			case ConstraintType::FOREIGN_KEY:
+			case ConstraintType::FOREIGN_KEY: {
+				auto &bound_foreign_key = (BoundForeignKeyConstraint &)bound_constraint;
+				for (auto &col_idx : bound_foreign_key.info.fk_keys) {
+					column_index_list.push_back(column_t(col_idx));
+				}
+				break;
+			}
 			default:
 				throw NotImplementedException("Unimplemented constraint for duckdb_constraints");
 			}
@@ -98435,9 +98745,9 @@ void DuckDBIndexesFunction(ClientContext &context, const FunctionData *bind_data
 		auto table_entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, index.info->schema, index.info->table);
 		output.SetValue(5, count, Value::BIGINT(table_entry->oid));
 		// is_unique, BOOLEAN
-		output.SetValue(6, count, Value::BOOLEAN(index.index->is_unique));
+		output.SetValue(6, count, Value::BOOLEAN(index.index->IsUnique()));
 		// is_primary, BOOLEAN
-		output.SetValue(7, count, Value::BOOLEAN(index.index->is_primary));
+		output.SetValue(7, count, Value::BOOLEAN(index.index->IsPrimary()));
 		// expressions, VARCHAR
 		output.SetValue(8, count, Value());
 		// sql, VARCHAR
@@ -133299,6 +133609,9 @@ unique_ptr<Constraint> Constraint::Deserialize(Deserializer &source) {
 	case ConstraintType::UNIQUE:
 		result = UniqueConstraint::Deserialize(reader);
 		break;
+	case ConstraintType::FOREIGN_KEY:
+		result = ForeignKeyConstraint::Deserialize(reader);
+		break;
 	default:
 		throw InternalException("Unrecognized constraint type for serialization");
 	}
@@ -133343,6 +133656,82 @@ unique_ptr<Constraint> CheckConstraint::Deserialize(FieldReader &source) {
 
 
 
+
+
+namespace duckdb {
+
+ForeignKeyConstraint::ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info)
+    : Constraint(ConstraintType::FOREIGN_KEY), pk_columns(move(pk_columns)), fk_columns(move(fk_columns)),
+      info(move(info)) {
+}
+
+string ForeignKeyConstraint::ToString() const {
+	if (info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+		string base = "FOREIGN KEY (";
+
+		for (idx_t i = 0; i < fk_columns.size(); i++) {
+			if (i > 0) {
+				base += ", ";
+			}
+			base += KeywordHelper::WriteOptionallyQuoted(fk_columns[i]);
+		}
+		base += ") REFERENCES ";
+		if (!info.schema.empty()) {
+			base += info.schema;
+			base += ".";
+		}
+		base += info.table;
+		base += "(";
+
+		for (idx_t i = 0; i < pk_columns.size(); i++) {
+			if (i > 0) {
+				base += ", ";
+			}
+			base += KeywordHelper::WriteOptionallyQuoted(pk_columns[i]);
+		}
+		base += ")";
+
+		return base;
+	}
+
+	return "";
+}
+
+unique_ptr<Constraint> ForeignKeyConstraint::Copy() const {
+	return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, info);
+}
+
+void ForeignKeyConstraint::Serialize(FieldWriter &writer) const {
+	D_ASSERT(pk_columns.size() <= NumericLimits<uint32_t>::Maximum());
+	writer.WriteList<string>(pk_columns);
+	D_ASSERT(fk_columns.size() <= NumericLimits<uint32_t>::Maximum());
+	writer.WriteList<string>(fk_columns);
+	writer.WriteField<ForeignKeyType>(info.type);
+	writer.WriteString(info.schema);
+	writer.WriteString(info.table);
+	writer.WriteList<idx_t>(info.pk_keys);
+	writer.WriteList<idx_t>(info.fk_keys);
+}
+
+unique_ptr<Constraint> ForeignKeyConstraint::Deserialize(FieldReader &source) {
+	ForeignKeyInfo read_info;
+	auto pk_columns = source.ReadRequiredList<string>();
+	auto fk_columns = source.ReadRequiredList<string>();
+	read_info.type = source.ReadRequired<ForeignKeyType>();
+	read_info.schema = source.ReadRequired<string>();
+	read_info.table = source.ReadRequired<string>();
+	read_info.pk_keys = source.ReadRequiredList<idx_t>();
+	read_info.fk_keys = source.ReadRequiredList<idx_t>();
+
+	// column list parsed constraint
+	return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, move(read_info));
+}
+
+} // namespace duckdb
+
+
+
+
 namespace duckdb {
 
 NotNullConstraint::NotNullConstraint(column_t index) : Constraint(ConstraintType::NOT_NULL), index(index) {
@@ -134755,6 +135144,8 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 		return ChangeColumnTypeInfo::Deserialize(reader, schema, table);
 	case AlterTableType::SET_DEFAULT:
 		return SetDefaultInfo::Deserialize(reader, schema, table);
+	case AlterTableType::FOREIGN_KEY_CONSTRAINT:
+		return AlterForeignKeyInfo::Deserialize(reader, schema, table);
 	default:
 		throw SerializationException("Unknown alter table type for deserialization!");
 	}
@@ -134911,6 +135302,44 @@ unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, string sc
 	return make_unique<SetDefaultInfo>(move(schema), move(table), move(column_name), move(new_default));
 }
 
+//===--------------------------------------------------------------------===//
+// AlterForeignKeyInfo
+//===--------------------------------------------------------------------===//
+AlterForeignKeyInfo::AlterForeignKeyInfo(string schema_p, string table_p, string fk_table, vector<string> pk_columns,
+                                         vector<string> fk_columns, vector<idx_t> pk_keys, vector<idx_t> fk_keys,
+                                         AlterForeignKeyType type_p)
+    : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT, move(schema_p), move(table_p)), fk_table(move(fk_table)),
+      pk_columns(move(pk_columns)), fk_columns(move(fk_columns)), pk_keys(move(pk_keys)), fk_keys(move(fk_keys)),
+      type(type_p) {
+}
+AlterForeignKeyInfo::~AlterForeignKeyInfo() {
+}
+
+unique_ptr<AlterInfo> AlterForeignKeyInfo::Copy() const {
+	return make_unique_base<AlterInfo, AlterForeignKeyInfo>(schema, name, fk_table, pk_columns, fk_columns, pk_keys,
+	                                                        fk_keys, type);
+}
+
+void AlterForeignKeyInfo::SerializeAlterTable(FieldWriter &writer) const {
+	writer.WriteString(fk_table);
+	writer.WriteList<string>(pk_columns);
+	writer.WriteList<string>(fk_columns);
+	writer.WriteList<idx_t>(pk_keys);
+	writer.WriteList<idx_t>(fk_keys);
+	writer.WriteField<AlterForeignKeyType>(type);
+}
+
+unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, string schema, string table) {
+	auto fk_table = reader.ReadRequired<string>();
+	auto pk_columns = reader.ReadRequiredList<string>();
+	auto fk_columns = reader.ReadRequiredList<string>();
+	auto pk_keys = reader.ReadRequiredList<idx_t>();
+	auto fk_keys = reader.ReadRequiredList<idx_t>();
+	auto type = reader.ReadRequired<AlterForeignKeyType>();
+	return make_unique<AlterForeignKeyInfo>(move(schema), move(table), move(fk_table), move(pk_columns),
+	                                        move(fk_columns), move(pk_keys), move(fk_keys), type);
+}
+
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
@@ -142779,6 +143208,30 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		}
 		return make_unique<CheckConstraint>(TransformExpression(constraint->raw_expr));
 	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
+		ForeignKeyInfo fk_info;
+		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
+		if (constraint->pktable->schemaname) {
+			fk_info.schema = constraint->pktable->schemaname;
+		} else {
+			fk_info.schema = "";
+		}
+		fk_info.table = constraint->pktable->relname;
+		vector<string> pk_columns, fk_columns;
+		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
+			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		}
+		for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
+			pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		}
+		if (pk_columns.size() != fk_columns.size()) {
+			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
+		}
+		if (fk_columns.empty()) {
+			throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
+		}
+		return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, move(fk_info));
+	}
 	default:
 		throw NotImplementedException("Constraint type not handled yet!");
 	}
@@ -151630,6 +152083,7 @@ public:
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
@@ -151816,6 +152270,34 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		break;
 	}
 	case CatalogType::TABLE_ENTRY: {
+		// If there is a foreign key constraint, resolve primary key column's index from primary key column's name
+		auto &create_info = (CreateTableInfo &)*stmt.info;
+		auto &catalog = Catalog::GetCatalog(context);
+		for (idx_t i = 0; i < create_info.constraints.size(); i++) {
+			auto &cond = create_info.constraints[i];
+			if (cond->type != ConstraintType::FOREIGN_KEY) {
+				continue;
+			}
+			auto &fk = (ForeignKeyConstraint &)*cond;
+			if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+				continue;
+			}
+			D_ASSERT(fk.info.pk_keys.empty() && !fk.pk_columns.empty());
+			if (create_info.table == fk.info.table) {
+				fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE;
+			} else {
+				// have to resolve referenced table
+				auto pk_table_entry_ptr = catalog.GetEntry<TableCatalogEntry>(context, fk.info.schema, fk.info.table);
+				D_ASSERT(!fk.pk_columns.empty() && fk.info.pk_keys.empty());
+				for (auto &keyname : fk.pk_columns) {
+					auto entry = pk_table_entry_ptr->name_map.find(keyname);
+					if (entry == pk_table_entry_ptr->name_map.end()) {
+						throw ParserException("column \"%s\" named in key does not exist", keyname);
+					}
+					fk.info.pk_keys.push_back(entry->second);
+				}
+			}
+		}
 		// We first check if there are any user types, if yes we check to which custom types they refer.
 		auto bound_info = BindCreateTableInfo(move(stmt.info));
 		auto root = move(bound_info->query);
@@ -151850,6 +152332,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -151986,6 +152469,39 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			    make_unique<BoundUniqueConstraint>(move(keys), move(key_set), unique.is_primary_key));
 			break;
 		}
+		case ConstraintType::FOREIGN_KEY: {
+			auto &fk = (ForeignKeyConstraint &)*cond;
+			D_ASSERT((fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE && !fk.info.pk_keys.empty()) ||
+			         (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && !fk.info.pk_keys.empty()) ||
+			         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
+			if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE && fk.info.pk_keys.empty()) {
+				for (auto &keyname : fk.pk_columns) {
+					auto entry = info.name_map.find(keyname);
+					if (entry == info.name_map.end()) {
+						throw ParserException("column \"%s\" named in key does not exist", keyname);
+					}
+					fk.info.pk_keys.push_back(entry->second);
+				}
+			}
+			if (fk.info.fk_keys.empty()) {
+				for (auto &keyname : fk.fk_columns) {
+					auto entry = info.name_map.find(keyname);
+					if (entry == info.name_map.end()) {
+						throw ParserException("column \"%s\" named in key does not exist", keyname);
+					}
+					fk.info.fk_keys.push_back(entry->second);
+				}
+			}
+			unordered_set<idx_t> fk_key_set, pk_key_set;
+			for (idx_t i = 0; i < fk.info.pk_keys.size(); i++) {
+				pk_key_set.insert(fk.info.pk_keys[i]);
+			}
+			for (idx_t i = 0; i < fk.info.fk_keys.size(); i++) {
+				fk_key_set.insert(fk.info.fk_keys[i]);
+			}
+			info.bound_constraints.push_back(make_unique<BoundForeignKeyConstraint>(fk.info, pk_key_set, fk_key_set));
+			break;
+		}
 		default:
 			throw NotImplementedException("unrecognized constraint type in bind");
 		}
@@ -152234,6 +152750,7 @@ BoundStatement Binder::Bind(ExplainStatement &stmt) {
 
 
 
+
 #include <algorithm>
 
 namespace duckdb {
@@ -152262,6 +152779,51 @@ string SanitizeExportIdentifier(const string &str) {
 	return result;
 }
 
+bool IsExistMainKeyTable(string &table_name, vector<TableCatalogEntry *> &unordered) {
+	for (idx_t i = 0; i < unordered.size(); i++) {
+		if (unordered[i]->name == table_name) {
+			return true;
+		}
+	}
+	return false;
+}
+
+void ScanForeignKeyTable(vector<TableCatalogEntry *> &ordered, vector<TableCatalogEntry *> &unordered,
+                         bool move_only_pk_table) {
+	for (auto i = unordered.begin(); i != unordered.end();) {
+		auto table_entry = *i;
+		bool move_to_ordered = true;
+		for (idx_t j = 0; j < table_entry->constraints.size(); j++) {
+			auto &cond = table_entry->constraints[j];
+			if (cond->type == ConstraintType::FOREIGN_KEY) {
+				auto &fk = (ForeignKeyConstraint &)*cond;
+				if ((move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) ||
+				    (!move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE &&
+				     IsExistMainKeyTable(fk.info.table, unordered))) {
+					move_to_ordered = false;
+					break;
+				}
+			}
+		}
+		if (move_to_ordered) {
+			ordered.push_back(table_entry);
+			i = unordered.erase(i);
+		} else {
+			i++;
+		}
+	}
+}
+
+void ReorderTableEntries(vector<TableCatalogEntry *> &tables) {
+	vector<TableCatalogEntry *> ordered;
+	vector<TableCatalogEntry *> unordered = tables;
+	ScanForeignKeyTable(ordered, unordered, true);
+	while (!unordered.empty()) {
+		ScanForeignKeyTable(ordered, unordered, false);
+	}
+	tables = ordered;
+}
+
 BoundStatement Binder::Bind(ExportStatement &stmt) {
 	// COPY TO a file
 	auto &config = DBConfig::GetConfig(context);
@@ -152290,6 +152852,9 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		});
 	}
 
+	// reorder tables because of foreign key constraint
+	ReorderTableEntries(tables);
+
 	// now generate the COPY statements for each of the tables
 	auto &fs = FileSystem::GetFileSystem(context);
 	unique_ptr<LogicalOperator> child_operator;
@@ -152324,7 +152889,10 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		exported_data.schema_name = info->schema;
 		exported_data.file_path = info->file_path;
 
-		exported_tables.data[table] = exported_data;
+		ExportedTableInfo table_info;
+		table_info.entry = table;
+		table_info.table_data = exported_data;
+		exported_tables.data.push_back(table_info);
 		id++;
 
 		// generate the copy statement and bind it
@@ -160277,6 +160845,8 @@ void WriteOverflowStringsToDisk::AllocateNewBlock(block_id_t new_block_id) {
 
 namespace duckdb {
 
+void ReorderTableEntries(vector<TableCatalogEntry *> &tables);
+
 CheckpointManager::CheckpointManager(DatabaseInstance &db) : db(db) {
 }
 
@@ -160421,6 +160991,8 @@ void CheckpointManager::WriteSchema(SchemaCatalogEntry &schema) {
 	for (auto &seq : sequences) {
 		WriteSequence(*seq);
 	}
+	// reorder tables because of foreign key constraint
+	ReorderTableEntries(tables);
 	// now write the tables
 	metadata_writer->Write<uint32_t>(tables.size());
 	for (auto &table : tables) {
@@ -165876,7 +166448,133 @@ static void VerifyCheckConstraint(TableCatalogEntry &table, Expression &expr, Da
 	}
 }
 
-void DataTable::VerifyAppendConstraints(TableCatalogEntry &table, DataChunk &chunk) {
+static bool FindColumnIndex(const vector<idx_t> *keys_ptr, const vector<column_t> &index_column_ids) {
+	for (idx_t i = 0; i < keys_ptr->size(); i++) {
+		bool is_found = false;
+		for (idx_t j = 0; j < index_column_ids.size(); j++) {
+			if ((*keys_ptr)[i] == index_column_ids[j]) {
+				is_found = true;
+				break;
+			}
+		}
+		if (!is_found) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+static void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context, DataChunk &chunk,
+                                       bool is_append) {
+	const vector<idx_t> *src_keys_ptr = &bfk.info.fk_keys;
+	const vector<idx_t> *dst_keys_ptr = &bfk.info.pk_keys;
+	if (!is_append) {
+		src_keys_ptr = &bfk.info.pk_keys;
+		dst_keys_ptr = &bfk.info.fk_keys;
+	}
+
+	auto table_entry_ptr =
+	    Catalog::GetCatalog(context).GetEntry<TableCatalogEntry>(context, bfk.info.schema, bfk.info.table);
+	if (table_entry_ptr == nullptr) {
+		throw InternalException("Can't find table \"%s\" in foreign key constraint", bfk.info.table);
+	}
+
+	// make the data chunk to check
+	vector<LogicalType> types;
+	for (idx_t i = 0; i < table_entry_ptr->columns.size(); i++) {
+		types.emplace_back(table_entry_ptr->columns[i].type);
+	}
+	DataChunk dst_chunk;
+	dst_chunk.InitializeEmpty(types);
+	for (idx_t i = 0; i < src_keys_ptr->size(); i++) {
+		dst_chunk.data[(*dst_keys_ptr)[i]].Reference(chunk.data[(*src_keys_ptr)[i]]);
+	}
+	dst_chunk.SetCardinality(chunk.size());
+	auto data_table = table_entry_ptr->storage.get();
+
+	idx_t count = dst_chunk.size();
+	if (count <= 0) {
+		return;
+	}
+
+	// we need to look at the error messages concurrently in data table's index and transaction local storage's index
+	vector<string> err_msgs, tran_err_msgs;
+	err_msgs.resize(count);
+	tran_err_msgs.resize(count);
+
+	// check whether or not the chunk can be inserted or deleted into the referenced table' storage
+	TableIndexList &table_indices = data_table->info->indexes;
+	table_indices.Scan([&](Index &index) {
+		if (FindColumnIndex(dst_keys_ptr, index.column_ids)) {
+			if (is_append) {
+				index.VerifyAppendForeignKey(dst_chunk, err_msgs.data());
+			} else {
+				index.VerifyDeleteForeignKey(dst_chunk, err_msgs.data());
+			}
+		}
+		return false;
+	});
+
+	// check whether or not the chunk can be inserted or deleted into the referenced table' transaction local storage
+	auto &transaction = Transaction::GetTransaction(context);
+	bool transaction_check = transaction.storage.Find(data_table);
+	if (transaction_check) {
+		vector<unique_ptr<Index>> &transact_index_vec = transaction.storage.GetIndexes(data_table);
+		for (idx_t i = 0; i < transact_index_vec.size(); i++) {
+			if (FindColumnIndex(dst_keys_ptr, transact_index_vec[i]->column_ids)) {
+				if (is_append) {
+					transact_index_vec[i]->VerifyAppendForeignKey(dst_chunk, tran_err_msgs.data());
+				} else {
+					transact_index_vec[i]->VerifyDeleteForeignKey(dst_chunk, tran_err_msgs.data());
+				}
+			}
+		}
+	}
+
+	// we need to look at the error messages concurrently in data table's index and transaction local storage's index
+	for (idx_t i = 0; i < count; i++) {
+		if (!transaction_check) {
+			// if there is no transaction-local data we only need to check if there is an error message in the main
+			// index
+			if (!err_msgs[i].empty()) {
+				throw ConstraintException(err_msgs[i]);
+			} else {
+				continue;
+			}
+		}
+		if (is_append) {
+			// if we are appending we need to check to ensure the foreign key exists in either the transaction-local
+			// storage or the main table
+			if (!err_msgs[i].empty() && !tran_err_msgs[i].empty()) {
+				throw ConstraintException(err_msgs[i]);
+			} else {
+				continue;
+			}
+		}
+		// if we are deleting we need to ensure the foreign key DOES NOT exist in EITHER the transaction-local storage
+		// OR the main table
+		if (!err_msgs[i].empty() || !tran_err_msgs[i].empty()) {
+			string &err_msg = err_msgs[i];
+			if (err_msg.empty()) {
+				err_msg = tran_err_msgs[i];
+			}
+			throw ConstraintException(err_msg);
+		}
+	}
+}
+
+static void VerifyAppendForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
+                                             DataChunk &chunk) {
+	VerifyForeignKeyConstraint(bfk, context, chunk, true);
+}
+
+static void VerifyDeleteForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
+                                             DataChunk &chunk) {
+	VerifyForeignKeyConstraint(bfk, context, chunk, false);
+}
+
+void DataTable::VerifyAppendConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk) {
 	for (auto &constraint : table.bound_constraints) {
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
@@ -165898,7 +166596,14 @@ void DataTable::VerifyAppendConstraints(TableCatalogEntry &table, DataChunk &chu
 			});
 			break;
 		}
-		case ConstraintType::FOREIGN_KEY:
+		case ConstraintType::FOREIGN_KEY: {
+			auto &bfk = *reinterpret_cast<BoundForeignKeyConstraint *>(constraint.get());
+			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
+			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
+				VerifyAppendForeignKeyConstraint(bfk, context, chunk);
+			}
+			break;
+		}
 		default:
 			throw NotImplementedException("Constraint type not implemented!");
 		}
@@ -165919,7 +166624,7 @@ void DataTable::Append(TableCatalogEntry &table, ClientContext &context, DataChu
 	chunk.Verify();
 
 	// verify any constraints on the new chunk
-	VerifyAppendConstraints(table, chunk);
+	VerifyAppendConstraints(table, context, chunk);
 
 	// append to the transaction local data
 	auto &transaction = Transaction::GetTransaction(context);
@@ -166211,6 +166916,27 @@ void DataTable::RemoveFromIndexes(Vector &row_identifiers, idx_t count) {
 	});
 }
 
+void DataTable::VerifyDeleteConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk) {
+	for (auto &constraint : table.bound_constraints) {
+		switch (constraint->type) {
+		case ConstraintType::NOT_NULL:
+		case ConstraintType::CHECK:
+		case ConstraintType::UNIQUE:
+			break;
+		case ConstraintType::FOREIGN_KEY: {
+			auto &bfk = *reinterpret_cast<BoundForeignKeyConstraint *>(constraint.get());
+			if (bfk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE ||
+			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
+				VerifyDeleteForeignKeyConstraint(bfk, context, chunk);
+			}
+			break;
+		}
+		default:
+			throw NotImplementedException("Constraint type not implemented!");
+		}
+	}
+}
+
 //===--------------------------------------------------------------------===//
 // Delete
 //===--------------------------------------------------------------------===//
@@ -166226,6 +166952,23 @@ idx_t DataTable::Delete(TableCatalogEntry &table, ClientContext &context, Vector
 	auto ids = FlatVector::GetData<row_t>(row_identifiers);
 	auto first_id = ids[0];
 
+	// verify any constraints on the delete rows
+	DataChunk verify_chunk;
+	if (first_id >= MAX_ROW_ID) {
+		transaction.storage.FetchChunk(this, row_identifiers, count, verify_chunk);
+	} else {
+		ColumnFetchState fetch_state;
+		vector<column_t> col_ids;
+		vector<LogicalType> types;
+		for (idx_t i = 0; i < column_definitions.size(); i++) {
+			col_ids.push_back(column_definitions[i].oid);
+			types.emplace_back(column_definitions[i].type);
+		}
+		verify_chunk.Initialize(types);
+		Fetch(transaction, verify_chunk, col_ids, row_identifiers, count, fetch_state);
+	}
+	VerifyDeleteConstraints(table, context, verify_chunk);
+
 	if (first_id >= MAX_ROW_ID) {
 		// deletion is in transaction-local storage: push delete into local chunk collection
 		return transaction.storage.Delete(this, row_identifiers, count);
@@ -166598,8 +167341,8 @@ vector<vector<Value>> DataTable::GetStorageInfo() {
 namespace duckdb {
 
 Index::Index(IndexType type, const vector<column_t> &column_ids_p,
-             const vector<unique_ptr<Expression>> &unbound_expressions, bool is_unique, bool is_primary)
-    : type(type), column_ids(column_ids_p), is_unique(is_unique), is_primary(is_primary) {
+             const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type_p)
+    : type(type), column_ids(column_ids_p), constraint_type(constraint_type_p) {
 	for (auto &expr : unbound_expressions) {
 		types.push_back(expr->return_type.InternalType());
 		logical_types.push_back(expr->return_type);
@@ -166723,13 +167466,13 @@ void LocalTableStorage::Clear() {
 	table.info->indexes.Scan([&](Index &index) {
 		D_ASSERT(index.type == IndexType::ART);
 		auto &art = (ART &)index;
-		if (art.is_unique) {
+		if (art.constraint_type != IndexConstraintType::NONE) {
 			// unique index: create a local ART index that maintains the same unique constraint
 			vector<unique_ptr<Expression>> unbound_expressions;
 			for (auto &expr : art.unbound_expressions) {
 				unbound_expressions.push_back(expr->Copy());
 			}
-			indexes.push_back(make_unique<ART>(art.column_ids, move(unbound_expressions), true));
+			indexes.push_back(make_unique<ART>(art.column_ids, move(unbound_expressions), art.constraint_type));
 		}
 		return false;
 	});
@@ -167123,6 +167866,30 @@ void LocalStorage::ChangeType(DataTable *old_dt, DataTable *new_dt, idx_t change
 	throw NotImplementedException("FIXME: ALTER TYPE with transaction local data not currently supported");
 }
 
+void LocalStorage::FetchChunk(DataTable *table, Vector &row_ids, idx_t count, DataChunk &dst_chunk) {
+	auto storage = GetStorage(table);
+	idx_t chunk_idx = GetChunk(row_ids);
+	auto &chunk = storage->collection.GetChunk(chunk_idx);
+
+	VectorData row_ids_data;
+	row_ids.Orrify(count, row_ids_data);
+	auto row_identifiers = (const row_t *)row_ids_data.data;
+	SelectionVector sel(count);
+	for (idx_t i = 0; i < count; ++i) {
+		const auto idx = row_ids_data.sel->get_index(i);
+		sel.set_index(i, row_identifiers[idx] - MAX_ROW_ID);
+	}
+
+	dst_chunk.InitializeEmpty(chunk.GetTypes());
+	dst_chunk.Slice(chunk, sel, count);
+}
+
+vector<unique_ptr<Index>> &LocalStorage::GetIndexes(DataTable *table) {
+	auto storage = GetStorage(table);
+
+	return storage->indexes;
+}
+
 } // namespace duckdb