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

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "8b73feaf4"
-#define DUCKDB_VERSION "v0.3.3-dev944"
+#define DUCKDB_SOURCE_ID "440cba203"
+#define DUCKDB_VERSION "v0.3.3-dev977"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -11155,6 +11155,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 class Serializer;
@@ -11173,6 +11174,24 @@ enum class ConstraintType : uint8_t {
 	FOREIGN_KEY = 4 // FOREIGN KEY constraint
 };
 
+enum class ForeignKeyType : uint8_t {
+	FK_TYPE_PRIMARY_KEY_TABLE = 0,   // main table
+	FK_TYPE_FOREIGN_KEY_TABLE = 1,   // referencing table
+	FK_TYPE_SELF_REFERENCE_TABLE = 2 // self refrencing table
+};
+
+struct ForeignKeyInfo {
+	ForeignKeyType type;
+	string schema;
+	//! if type is FK_TYPE_FOREIGN_KEY_TABLE, means main key table, if type is FK_TYPE_PRIMARY_KEY_TABLE, means foreign
+	//! key table
+	string table;
+	//! The set of main key table's column's index
+	vector<idx_t> pk_keys;
+	//! The set of foreign key table's column's index
+	vector<idx_t> fk_keys;
+};
+
 //! Constraint is the base class of any type of table constraint.
 class Constraint {
 public:
@@ -11235,6 +11254,7 @@ struct AddColumnInfo;
 struct RemoveColumnInfo;
 struct SetDefaultInfo;
 struct ChangeColumnTypeInfo;
+struct AlterForeignKeyInfo;
 
 //! A table catalog entry
 class TableCatalogEntry : public StandardEntry {
@@ -11289,6 +11309,7 @@ private:
 	unique_ptr<CatalogEntry> RemoveColumn(ClientContext &context, RemoveColumnInfo &info);
 	unique_ptr<CatalogEntry> SetDefault(ClientContext &context, SetDefaultInfo &info);
 	unique_ptr<CatalogEntry> ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info);
+	unique_ptr<CatalogEntry> SetForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
 };
 } // namespace duckdb
 
@@ -11460,6 +11481,8 @@ enum class AlterType : uint8_t {
 	CHANGE_OWNERSHIP = 4
 };
 
+enum AlterForeignKeyType : uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };
+
 struct AlterInfo : public ParseInfo {
 	AlterInfo(AlterType type, string schema, string name);
 	~AlterInfo() override;
@@ -11509,7 +11532,8 @@ enum class AlterTableType : uint8_t {
 	ADD_COLUMN = 3,
 	REMOVE_COLUMN = 4,
 	ALTER_COLUMN_TYPE = 5,
-	SET_DEFAULT = 6
+	SET_DEFAULT = 6,
+	FOREIGN_KEY_CONSTRAINT = 7
 };
 
 struct AlterTableInfo : public AlterInfo {
@@ -11632,6 +11656,28 @@ public:
 	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
 };
 
+//===--------------------------------------------------------------------===//
+// AlterForeignKeyInfo
+//===--------------------------------------------------------------------===//
+struct AlterForeignKeyInfo : public AlterTableInfo {
+	AlterForeignKeyInfo(string schema, string table, string fk_table, vector<string> pk_columns,
+	                    vector<string> fk_columns, vector<idx_t> pk_keys, vector<idx_t> fk_keys,
+	                    AlterForeignKeyType type);
+	~AlterForeignKeyInfo() override;
+
+	string fk_table;
+	vector<string> pk_columns;
+	vector<string> fk_columns;
+	vector<idx_t> pk_keys;
+	vector<idx_t> fk_keys;
+	AlterForeignKeyType type;
+
+public:
+	unique_ptr<AlterInfo> Copy() const override;
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
+};
+
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
@@ -12638,6 +12684,7 @@ class Constraint;
 class NotNullConstraint;
 class CheckConstraint;
 class UniqueConstraint;
+class ForeignKeyConstraint;
 
 //===--------------------------------------------------------------------===//
 // TableRefs
@@ -14458,6 +14505,9 @@ public:
 	void ChangeType(DataTable *old_dt, DataTable *new_dt, idx_t changed_idx, const LogicalType &target_type,
 	                const vector<column_t> &bound_columns, Expression &cast_expr);
 
+	void FetchChunk(DataTable *table, Vector &row_ids, idx_t count, DataChunk &chunk);
+	vector<unique_ptr<Index>> &GetIndexes(DataTable *table);
+
 private:
 	LocalTableStorage *GetStorage(DataTable *table);
 
@@ -16518,6 +16568,8 @@ class LogicalOperator;
 class QueryNode;
 class TableRef;
 
+class ExtraDependencies {};
+
 class Relation : public std::enable_shared_from_this<Relation> {
 public:
 	DUCKDB_API Relation(const std::shared_ptr<ClientContext> &context, RelationType type)
@@ -16532,6 +16584,8 @@ public:
 
 	RelationType type;
 
+	unique_ptr<ExtraDependencies> extra_dependencies;
+
 public:
 	DUCKDB_API virtual const vector<ColumnDefinition> &Columns() = 0;
 	DUCKDB_API virtual unique_ptr<QueryNode> GetQueryNode();
@@ -19241,11 +19295,18 @@ class Transaction;
 
 struct IndexLock;
 
+enum IndexConstraintType : uint8_t {
+	NONE = 0,    // index is an index don't built to any constraint
+	UNIQUE = 1,  // index is an index built to enforce a UNIQUE constraint
+	PRIMARY = 2, // index is an index built to enforce a PRIMARY KEY constraint
+	FOREIGN = 3  // index is an index built to enforce a FOREIGN KEY constraint
+};
+
 //! The index is an abstract base class that serves as the basis for indexes
 class Index {
 public:
 	Index(IndexType type, const vector<column_t> &column_ids, const vector<unique_ptr<Expression>> &unbound_expressions,
-	      bool is_unique, bool is_primary);
+	      IndexConstraintType constraint_type);
 	virtual ~Index() = default;
 
 	//! The type of the index
@@ -19260,10 +19321,8 @@ public:
 	vector<PhysicalType> types;
 	//! The logical types of the expressions
 	vector<LogicalType> logical_types;
-	//! Whether or not the index is an index built to enforce a UNIQUE or PRIMARY KEY constraint
-	bool is_unique;
-	//! Whether or not the index is an index built to enforce a PRIMARY KEY constraint
-	bool is_primary;
+	// ! constraint type
+	IndexConstraintType constraint_type;
 
 public:
 	//! Initialize a scan on the index with the given expression and column ids
@@ -19287,6 +19346,10 @@ public:
 	bool Append(DataChunk &entries, Vector &row_identifiers);
 	//! Verify that data can be appended to the index
 	virtual void VerifyAppend(DataChunk &chunk) = 0;
+	//! Verify that data can be appended to the index for foreign key constraint
+	virtual void VerifyAppendForeignKey(DataChunk &chunk, string *err_msg_ptr) = 0;
+	//! Verify that data can be delete from the index for foreign key constraint
+	virtual void VerifyDeleteForeignKey(DataChunk &chunk, string *err_msg_ptr) = 0;
 
 	//! Called when data inside the index is Deleted
 	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
@@ -19298,6 +19361,19 @@ public:
 	//! Returns true if the index is affected by updates on the specified column ids, and false otherwise
 	bool IndexIsUpdated(const vector<column_t> &column_ids) const;
 
+	//! Returns unique flag
+	bool IsUnique() {
+		return (constraint_type == IndexConstraintType::UNIQUE || constraint_type == IndexConstraintType::PRIMARY);
+	}
+	//! Returns primary flag
+	bool IsPrimary() {
+		return (constraint_type == IndexConstraintType::PRIMARY);
+	}
+	//! Returns foreign flag
+	bool IsForeign() {
+		return (constraint_type == IndexConstraintType::FOREIGN);
+	}
+
 protected:
 	void ExecuteExpressions(DataChunk &input, DataChunk &result);
 
@@ -20157,9 +20233,11 @@ public:
 
 private:
 	//! Verify constraints with a chunk from the Append containing all columns of the table
-	void VerifyAppendConstraints(TableCatalogEntry &table, DataChunk &chunk);
+	void VerifyAppendConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
 	//! Verify constraints with a chunk from the Update containing only the specified column_ids
 	void VerifyUpdateConstraints(TableCatalogEntry &table, DataChunk &chunk, const vector<column_t> &column_ids);
+	//! Verify constraints with a chunk from the Delete containing all columns of the table
+	void VerifyDeleteConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
 
 	void InitializeScanWithOffset(TableScanState &state, const vector<column_t> &column_ids, idx_t start_row,
 	                              idx_t end_row);
@@ -22657,8 +22735,13 @@ struct ExportedTableData {
 	string file_path;
 };
 
+struct ExportedTableInfo {
+	TableCatalogEntry *entry;
+	ExportedTableData table_data;
+};
+
 struct BoundExportData : public ParseInfo {
-	unordered_map<TableCatalogEntry *, ExportedTableData> data;
+	std::vector<ExportedTableInfo> data;
 };
 
 } // namespace duckdb