duckdb 0.4.1-dev2385.0 → 0.4.1-dev2399.0

package/src/duckdb.cpp

@@ -2459,6 +2459,7 @@ unique_ptr<CreateMacroInfo> TableMacroCatalogEntry::Deserialize(Deserializer &ma
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -2502,6 +2503,7 @@ private:
 
 } // namespace duckdb
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -2531,64 +2533,20 @@ public:
 
 } // namespace duckdb
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/planner/constraints/bound_foreign_key_constraint.hpp
+// duckdb/common/algorithm.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
+#include <algorithm>
 
 
 
-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
 //
@@ -2630,17 +2588,59 @@ public:
 
 
 
+
+
+
+
+
+
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/algorithm.hpp
+// duckdb/planner/constraints/bound_foreign_key_constraint.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
-#include <algorithm>
+
+
+
+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
+
+
+
 
 #include <sstream>
 
@@ -2659,7 +2659,7 @@ void FindForeignKeyInformation(CatalogEntry *entry, AlterForeignKeyType alter_fk
 		}
 		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_arrays.push_back(make_unique<AlterForeignKeyInfo>(fk.info.schema, fk.info.table, false, 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 &&
@@ -3025,6 +3025,9 @@ string SequenceCatalogEntry::ToSQL() {
 
 
 
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -3105,6 +3108,76 @@ public:
 
 
 
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_expression_iterator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+#include <functional>
+
+namespace duckdb {
+
+class ParsedExpressionIterator {
+public:
+	static void EnumerateChildren(const ParsedExpression &expression,
+	                              const std::function<void(const ParsedExpression &child)> &callback);
+	static void EnumerateChildren(ParsedExpression &expr, const std::function<void(ParsedExpression &child)> &callback);
+	static void EnumerateChildren(ParsedExpression &expr,
+	                              const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
+
+	static void EnumerateTableRefChildren(TableRef &ref,
+	                                      const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
+	static void EnumerateQueryNodeChildren(QueryNode &node,
+	                                       const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
+
+	static void EnumerateQueryNodeModifiers(QueryNode &node,
+	                                        const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
+};
+
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/constraints/bound_check_constraint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+//! The CheckConstraint contains an expression that must evaluate to TRUE for
+//! every row in a table
+class BoundCheckConstraint : public BoundConstraint {
+public:
+	BoundCheckConstraint() : BoundConstraint(ConstraintType::CHECK) {
+	}
+
+	//! The expression
+	unique_ptr<Expression> expression;
+	//! The columns used by the CHECK constraint
+	unordered_set<column_t> bound_columns;
+};
+
+} // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -3168,10 +3241,11 @@ public:
 
 } // namespace duckdb
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/planner/constraints/bound_check_constraint.hpp
+// duckdb/planner/expression_binder/alter_binder.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -3181,26 +3255,32 @@ public:
 
 
 
-
 namespace duckdb {
+class TableCatalogEntry;
 
-//! The CheckConstraint contains an expression that must evaluate to TRUE for
-//! every row in a table
-class BoundCheckConstraint : public BoundConstraint {
+//! The ALTER binder is responsible for binding an expression within alter statements
+class AlterBinder : public ExpressionBinder {
 public:
-	BoundCheckConstraint() : BoundConstraint(ConstraintType::CHECK) {
-	}
+	AlterBinder(Binder &binder, ClientContext &context, TableCatalogEntry &table, vector<column_t> &bound_columns,
+	            LogicalType target_type);
 
-	//! The expression
-	unique_ptr<Expression> expression;
-	//! The columns used by the CHECK constraint
-	unordered_set<column_t> bound_columns;
+	TableCatalogEntry &table;
+	vector<column_t> &bound_columns;
+
+protected:
+	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	                          bool root_expression = false) override;
+
+	BindResult BindColumn(ColumnRefExpression &expr);
+
+	string UnsupportedAggregateMessage() override;
 };
 
 } // namespace duckdb
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -3445,86 +3525,6 @@ private:
 } // namespace duckdb
 
 
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_expression_iterator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-class ParsedExpressionIterator {
-public:
-	static void EnumerateChildren(const ParsedExpression &expression,
-	                              const std::function<void(const ParsedExpression &child)> &callback);
-	static void EnumerateChildren(ParsedExpression &expr, const std::function<void(ParsedExpression &child)> &callback);
-	static void EnumerateChildren(ParsedExpression &expr,
-	                              const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-
-	static void EnumerateTableRefChildren(TableRef &ref,
-	                                      const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-	static void EnumerateQueryNodeChildren(QueryNode &node,
-	                                       const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-
-	static void EnumerateQueryNodeModifiers(QueryNode &node,
-	                                        const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/alter_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class TableCatalogEntry;
-
-//! The ALTER binder is responsible for binding an expression within alter statements
-class AlterBinder : public ExpressionBinder {
-public:
-	AlterBinder(Binder &binder, ClientContext &context, TableCatalogEntry &table, vector<column_t> &bound_columns,
-	            LogicalType target_type);
-
-	TableCatalogEntry &table;
-	vector<column_t> &bound_columns;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	BindResult BindColumn(ColumnRefExpression &expr);
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-
-
-
 #include <sstream>
 
 namespace duckdb {
@@ -3545,6 +3545,10 @@ column_t TableCatalogEntry::GetColumnIndex(string &column_name, bool if_exists)
 			throw BinderException("Table \"%s\" does not have a column with name \"%s\"", name, column_name);
 		}
 	}
+	if (entry->second == COLUMN_IDENTIFIER_ROW_ID) {
+		column_name = "rowid";
+		return COLUMN_IDENTIFIER_ROW_ID;
+	}
 	column_name = GetColumnName(entry->second);
 	return entry->second;
 }
@@ -3797,6 +3801,13 @@ unique_ptr<CatalogEntry> TableCatalogEntry::RenameColumn(ClientContext &context,
 }
 
 unique_ptr<CatalogEntry> TableCatalogEntry::AddColumn(ClientContext &context, AddColumnInfo &info) {
+	auto col_name = info.new_column.GetName();
+
+	// We're checking for the opposite condition (ADD COLUMN IF _NOT_ EXISTS ...).
+	if (info.if_column_not_exists && GetColumnIndex(col_name, true) != DConstants::INVALID_INDEX) {
+		return nullptr;
+	}
+
 	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
 	create_info->temporary = temporary;
 
@@ -3823,7 +3834,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::AddColumn(ClientContext &context, Ad
 }
 
 unique_ptr<CatalogEntry> TableCatalogEntry::RemoveColumn(ClientContext &context, RemoveColumnInfo &info) {
-	auto removed_index = GetColumnIndex(info.removed_column, info.if_exists);
+	auto removed_index = GetColumnIndex(info.removed_column, info.if_column_exists);
 	if (removed_index == DConstants::INVALID_INDEX) {
 		return nullptr;
 	}
@@ -160038,10 +160049,11 @@ string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote) {
 
 
 
+
 namespace duckdb {
 
-AlterInfo::AlterInfo(AlterType type, string schema_p, string name_p)
-    : type(type), if_exists(false), schema(move(schema_p)), name(move(name_p)) {
+AlterInfo::AlterInfo(AlterType type, string schema_p, string name_p, bool if_exists)
+    : type(type), if_exists(if_exists), schema(move(schema_p)), name(move(name_p)) {
 }
 
 AlterInfo::~AlterInfo() {
@@ -160078,8 +160090,8 @@ unique_ptr<AlterInfo> AlterInfo::Deserialize(Deserializer &source) {
 // ChangeOwnershipInfo
 //===--------------------------------------------------------------------===//
 ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_schema_p, string entry_name_p,
-                                         string owner_schema_p, string owner_name_p)
-    : AlterInfo(AlterType::CHANGE_OWNERSHIP, move(entry_schema_p), move(entry_name_p)),
+                                         string owner_schema_p, string owner_name_p, bool if_exists)
+    : AlterInfo(AlterType::CHANGE_OWNERSHIP, move(entry_schema_p), move(entry_name_p), if_exists),
       entry_catalog_type(entry_catalog_type), owner_schema(move(owner_schema_p)), owner_name(move(owner_name_p)) {
 }
 
@@ -160088,7 +160100,8 @@ CatalogType ChangeOwnershipInfo::GetCatalogType() const {
 }
 
 unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
-	return make_unique_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, schema, name, owner_schema, owner_name);
+	return make_unique_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, schema, name, owner_schema, owner_name,
+	                                                        if_exists);
 }
 
 void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
@@ -160098,8 +160111,8 @@ void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
 //===--------------------------------------------------------------------===//
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
-AlterTableInfo::AlterTableInfo(AlterTableType type, string schema_p, string table_p)
-    : AlterInfo(AlterType::ALTER_TABLE, move(move(schema_p)), move(table_p)), alter_table_type(type) {
+AlterTableInfo::AlterTableInfo(AlterTableType type, string schema_p, string table_p, bool if_exists)
+    : AlterInfo(AlterType::ALTER_TABLE, move(move(schema_p)), move(table_p), if_exists), alter_table_type(type) {
 }
 AlterTableInfo::~AlterTableInfo() {
 }
@@ -160112,6 +160125,7 @@ void AlterTableInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteField<AlterTableType>(alter_table_type);
 	writer.WriteString(schema);
 	writer.WriteString(name);
+	writer.WriteField(if_exists);
 	SerializeAlterTable(writer);
 }
 
@@ -160119,26 +160133,28 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 	auto type = reader.ReadRequired<AlterTableType>();
 	auto schema = reader.ReadRequired<string>();
 	auto table = reader.ReadRequired<string>();
+	auto if_exists = reader.ReadRequired<bool>();
+
 	unique_ptr<AlterTableInfo> info;
 	switch (type) {
 	case AlterTableType::RENAME_COLUMN:
-		return RenameColumnInfo::Deserialize(reader, schema, table);
+		return RenameColumnInfo::Deserialize(reader, schema, table, if_exists);
 	case AlterTableType::RENAME_TABLE:
-		return RenameTableInfo::Deserialize(reader, schema, table);
+		return RenameTableInfo::Deserialize(reader, schema, table, if_exists);
 	case AlterTableType::ADD_COLUMN:
-		return AddColumnInfo::Deserialize(reader, schema, table);
+		return AddColumnInfo::Deserialize(reader, schema, table, if_exists);
 	case AlterTableType::REMOVE_COLUMN:
-		return RemoveColumnInfo::Deserialize(reader, schema, table);
+		return RemoveColumnInfo::Deserialize(reader, schema, table, if_exists);
 	case AlterTableType::ALTER_COLUMN_TYPE:
-		return ChangeColumnTypeInfo::Deserialize(reader, schema, table);
+		return ChangeColumnTypeInfo::Deserialize(reader, schema, table, if_exists);
 	case AlterTableType::SET_DEFAULT:
-		return SetDefaultInfo::Deserialize(reader, schema, table);
+		return SetDefaultInfo::Deserialize(reader, schema, table, if_exists);
 	case AlterTableType::FOREIGN_KEY_CONSTRAINT:
-		return AlterForeignKeyInfo::Deserialize(reader, schema, table);
+		return AlterForeignKeyInfo::Deserialize(reader, schema, table, if_exists);
 	case AlterTableType::SET_NOT_NULL:
-		return SetNotNullInfo::Deserialize(reader, schema, table);
+		return SetNotNullInfo::Deserialize(reader, schema, table, if_exists);
 	case AlterTableType::DROP_NOT_NULL:
-		return DropNotNullInfo::Deserialize(reader, schema, table);
+		return DropNotNullInfo::Deserialize(reader, schema, table, if_exists);
 	default:
 		throw SerializationException("Unknown alter table type for deserialization!");
 	}
@@ -160147,15 +160163,16 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 //===--------------------------------------------------------------------===//
 // RenameColumnInfo
 //===--------------------------------------------------------------------===//
-RenameColumnInfo::RenameColumnInfo(string schema_p, string table_p, string old_name_p, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_COLUMN, move(schema_p), move(table_p)), old_name(move(old_name_p)),
-      new_name(move(new_name_p)) {
+RenameColumnInfo::RenameColumnInfo(string schema_p, string table_p, bool if_exists_p, string old_name_p,
+                                   string new_name_p)
+    : AlterTableInfo(AlterTableType::RENAME_COLUMN, move(schema_p), move(table_p), if_exists_p),
+      old_name(move(old_name_p)), new_name(move(new_name_p)) {
 }
 RenameColumnInfo::~RenameColumnInfo() {
 }
 
 unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameColumnInfo>(schema, name, old_name, new_name);
+	return make_unique_base<AlterInfo, RenameColumnInfo>(schema, name, if_exists, old_name, new_name);
 }
 
 void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -160163,96 +160180,104 @@ void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(new_name);
 }
 
-unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
 	auto old_name = reader.ReadRequired<string>();
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameColumnInfo>(move(schema), move(table), old_name, new_name);
+	return make_unique<RenameColumnInfo>(move(schema), move(table), if_exists, old_name, new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
-RenameTableInfo::RenameTableInfo(string schema_p, string table_p, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_TABLE, move(schema_p), move(table_p)), new_table_name(move(new_name_p)) {
+RenameTableInfo::RenameTableInfo(string schema_p, string table_p, bool if_exists, string new_name_p)
+    : AlterTableInfo(AlterTableType::RENAME_TABLE, move(schema_p), move(table_p), if_exists),
+      new_table_name(move(new_name_p)) {
 }
 RenameTableInfo::~RenameTableInfo() {
 }
 
 unique_ptr<AlterInfo> RenameTableInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameTableInfo>(schema, name, new_table_name);
+	return make_unique_base<AlterInfo, RenameTableInfo>(schema, name, if_exists, new_table_name);
 }
 
 void RenameTableInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(new_table_name);
 }
 
-unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameTableInfo>(move(schema), move(table), new_name);
+	return make_unique<RenameTableInfo>(move(schema), move(table), if_exists, new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
-AddColumnInfo::AddColumnInfo(string schema_p, string table_p, ColumnDefinition new_column)
-    : AlterTableInfo(AlterTableType::ADD_COLUMN, move(schema_p), move(table_p)), new_column(move(new_column)) {
+AddColumnInfo::AddColumnInfo(string schema_p, string table_p, bool if_exists_p, ColumnDefinition new_column,
+                             bool if_column_not_exists)
+    : AlterTableInfo(AlterTableType::ADD_COLUMN, move(schema_p), move(table_p), if_exists_p),
+      new_column(move(new_column)), if_column_not_exists(if_column_not_exists) {
 }
+
 AddColumnInfo::~AddColumnInfo() {
 }
 
 unique_ptr<AlterInfo> AddColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, AddColumnInfo>(schema, name, new_column.Copy());
+	return make_unique_base<AlterInfo, AddColumnInfo>(schema, name, if_exists, new_column.Copy(), if_column_not_exists);
 }
 
 void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteSerializable(new_column);
+	writer.WriteField<bool>(if_column_not_exists);
 }
 
-unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
 	auto new_column = reader.ReadRequiredSerializable<ColumnDefinition, ColumnDefinition>();
-	return make_unique<AddColumnInfo>(move(schema), move(table), move(new_column));
+	auto if_column_not_exists = reader.ReadRequired<bool>();
+	return make_unique<AddColumnInfo>(move(schema), move(table), if_exists, move(new_column), if_column_not_exists);
 }
 
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
-RemoveColumnInfo::RemoveColumnInfo(string schema, string table, string removed_column, bool if_exists, bool cascade)
-    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, move(schema), move(table)), removed_column(move(removed_column)),
-      if_exists(if_exists), cascade(cascade) {
+RemoveColumnInfo::RemoveColumnInfo(string schema, string table, bool if_exists, string removed_column,
+                                   bool if_column_exists, bool cascade)
+    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, move(schema), move(table), if_exists),
+      removed_column(move(removed_column)), if_column_exists(if_column_exists), cascade(cascade) {
 }
 RemoveColumnInfo::~RemoveColumnInfo() {
 }
 
 unique_ptr<AlterInfo> RemoveColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, RemoveColumnInfo>(schema, name, removed_column, if_exists, cascade);
+	return make_unique_base<AlterInfo, RemoveColumnInfo>(schema, name, if_exists, removed_column, if_column_exists,
+	                                                     cascade);
 }
 
 void RemoveColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(removed_column);
-	writer.WriteField<bool>(if_exists);
+	writer.WriteField<bool>(if_column_exists);
 	writer.WriteField<bool>(cascade);
 }
 
-unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
 	auto new_name = reader.ReadRequired<string>();
-	auto if_exists = reader.ReadRequired<bool>();
+	auto if_column_exists = reader.ReadRequired<bool>();
 	auto cascade = reader.ReadRequired<bool>();
-	return make_unique<RemoveColumnInfo>(move(schema), move(table), new_name, if_exists, cascade);
+	return make_unique<RemoveColumnInfo>(move(schema), move(table), if_exists, new_name, if_column_exists, cascade);
 }
 
 //===--------------------------------------------------------------------===//
 // ChangeColumnTypeInfo
 //===--------------------------------------------------------------------===//
-ChangeColumnTypeInfo::ChangeColumnTypeInfo(string schema_p, string table_p, string column_name, LogicalType target_type,
-                                           unique_ptr<ParsedExpression> expression)
-    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, move(schema_p), move(table_p)), column_name(move(column_name)),
-      target_type(move(target_type)), expression(move(expression)) {
+ChangeColumnTypeInfo::ChangeColumnTypeInfo(string schema_p, string table_p, bool if_exists_p, string column_name,
+                                           LogicalType target_type, unique_ptr<ParsedExpression> expression)
+    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, move(schema_p), move(table_p), if_exists_p),
+      column_name(move(column_name)), target_type(move(target_type)), expression(move(expression)) {
 }
 ChangeColumnTypeInfo::~ChangeColumnTypeInfo() {
 }
 
 unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
-	return make_unique_base<AlterInfo, ChangeColumnTypeInfo>(schema, name, column_name, target_type,
+	return make_unique_base<AlterInfo, ChangeColumnTypeInfo>(schema, name, if_exists, column_name, target_type,
 	                                                         expression->Copy());
 }
 
@@ -160262,27 +160287,28 @@ void ChangeColumnTypeInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteOptional(expression);
 }
 
-unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, string schema, string table,
+                                                        bool if_exists) {
 	auto column_name = reader.ReadRequired<string>();
 	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<ChangeColumnTypeInfo>(move(schema), move(table), move(column_name), move(target_type),
+	return make_unique<ChangeColumnTypeInfo>(move(schema), move(table), if_exists, move(column_name), move(target_type),
 	                                         move(expression));
 }
 
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
-SetDefaultInfo::SetDefaultInfo(string schema_p, string table_p, string column_name_p,
+SetDefaultInfo::SetDefaultInfo(string schema_p, string table_p, bool if_exists_p, string column_name_p,
                                unique_ptr<ParsedExpression> new_default)
-    : AlterTableInfo(AlterTableType::SET_DEFAULT, move(schema_p), move(table_p)), column_name(move(column_name_p)),
-      expression(move(new_default)) {
+    : AlterTableInfo(AlterTableType::SET_DEFAULT, move(schema_p), move(table_p), if_exists_p),
+      column_name(move(column_name_p)), expression(move(new_default)) {
 }
 SetDefaultInfo::~SetDefaultInfo() {
 }
 
 unique_ptr<AlterInfo> SetDefaultInfo::Copy() const {
-	return make_unique_base<AlterInfo, SetDefaultInfo>(schema, name, column_name,
+	return make_unique_base<AlterInfo, SetDefaultInfo>(schema, name, if_exists, column_name,
 	                                                   expression ? expression->Copy() : nullptr);
 }
 
@@ -160291,72 +160317,74 @@ void SetDefaultInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteOptional(expression);
 }
 
-unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
 	auto column_name = reader.ReadRequired<string>();
 	auto new_default = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<SetDefaultInfo>(move(schema), move(table), move(column_name), move(new_default));
+	return make_unique<SetDefaultInfo>(move(schema), move(table), if_exists, move(column_name), move(new_default));
 }
 
 //===--------------------------------------------------------------------===//
 // SetNotNullInfo
 //===--------------------------------------------------------------------===//
-SetNotNullInfo::SetNotNullInfo(string schema_p, string table_p, string column_name_p)
-    : AlterTableInfo(AlterTableType::SET_NOT_NULL, move(schema_p), move(table_p)), column_name(move(column_name_p)) {
+SetNotNullInfo::SetNotNullInfo(string schema_p, string table_p, bool if_exists_p, string column_name_p)
+    : AlterTableInfo(AlterTableType::SET_NOT_NULL, move(schema_p), move(table_p), if_exists_p),
+      column_name(move(column_name_p)) {
 }
 SetNotNullInfo::~SetNotNullInfo() {
 }
 
 unique_ptr<AlterInfo> SetNotNullInfo::Copy() const {
-	return make_unique_base<AlterInfo, SetNotNullInfo>(schema, name, column_name);
+	return make_unique_base<AlterInfo, SetNotNullInfo>(schema, name, if_exists, column_name);
 }
 
 void SetNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(column_name);
 }
 
-unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
 	auto column_name = reader.ReadRequired<string>();
-	return make_unique<SetNotNullInfo>(move(schema), move(table), move(column_name));
+	return make_unique<SetNotNullInfo>(move(schema), move(table), if_exists, move(column_name));
 }
 
 //===--------------------------------------------------------------------===//
 // DropNotNullInfo
 //===--------------------------------------------------------------------===//
-DropNotNullInfo::DropNotNullInfo(string schema_p, string table_p, string column_name_p)
-    : AlterTableInfo(AlterTableType::DROP_NOT_NULL, move(schema_p), move(table_p)), column_name(move(column_name_p)) {
+DropNotNullInfo::DropNotNullInfo(string schema_p, string table_p, bool if_exists_p, string column_name_p)
+    : AlterTableInfo(AlterTableType::DROP_NOT_NULL, move(schema_p), move(table_p), if_exists_p),
+      column_name(move(column_name_p)) {
 }
 DropNotNullInfo::~DropNotNullInfo() {
 }
 
 unique_ptr<AlterInfo> DropNotNullInfo::Copy() const {
-	return make_unique_base<AlterInfo, DropNotNullInfo>(schema, name, column_name);
+	return make_unique_base<AlterInfo, DropNotNullInfo>(schema, name, if_exists, column_name);
 }
 
 void DropNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(column_name);
 }
 
-unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
 	auto column_name = reader.ReadRequired<string>();
-	return make_unique<DropNotNullInfo>(move(schema), move(table), move(column_name));
+	return make_unique<DropNotNullInfo>(move(schema), move(table), if_exists, move(column_name));
 }
 
 //===--------------------------------------------------------------------===//
 // 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(string schema_p, string table_p, bool if_exists_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), if_exists_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);
+	return make_unique_base<AlterInfo, AlterForeignKeyInfo>(schema, name, if_exists, fk_table, pk_columns, fk_columns,
+	                                                        pk_keys, fk_keys, type);
 }
 
 void AlterForeignKeyInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -160368,22 +160396,23 @@ void AlterForeignKeyInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteField<AlterForeignKeyType>(type);
 }
 
-unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, string schema, string table) {
+unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, string schema, string table,
+                                                       bool if_exists) {
 	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),
+	return make_unique<AlterForeignKeyInfo>(move(schema), move(table), if_exists, move(fk_table), move(pk_columns),
 	                                        move(fk_columns), move(pk_keys), move(fk_keys), type);
 }
 
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
-AlterViewInfo::AlterViewInfo(AlterViewType type, string schema_p, string view_p)
-    : AlterInfo(AlterType::ALTER_VIEW, move(schema_p), move(view_p)), alter_view_type(type) {
+AlterViewInfo::AlterViewInfo(AlterViewType type, string schema_p, string view_p, bool if_exists_p)
+    : AlterInfo(AlterType::ALTER_VIEW, move(schema_p), move(view_p), if_exists_p), alter_view_type(type) {
 }
 AlterViewInfo::~AlterViewInfo() {
 }
@@ -160396,6 +160425,7 @@ void AlterViewInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteField<AlterViewType>(alter_view_type);
 	writer.WriteString(schema);
 	writer.WriteString(name);
+	writer.WriteField<bool>(if_exists);
 	SerializeAlterView(writer);
 }
 
@@ -160403,10 +160433,11 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 	auto type = reader.ReadRequired<AlterViewType>();
 	auto schema = reader.ReadRequired<string>();
 	auto view = reader.ReadRequired<string>();
+	auto if_exists = reader.ReadRequired<bool>();
 	unique_ptr<AlterViewInfo> info;
 	switch (type) {
 	case AlterViewType::RENAME_VIEW:
-		return RenameViewInfo::Deserialize(reader, schema, view);
+		return RenameViewInfo::Deserialize(reader, schema, view, if_exists);
 	default:
 		throw SerializationException("Unknown alter view type for deserialization!");
 	}
@@ -160415,23 +160446,24 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 //===--------------------------------------------------------------------===//
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
-RenameViewInfo::RenameViewInfo(string schema_p, string view_p, string new_name_p)
-    : AlterViewInfo(AlterViewType::RENAME_VIEW, move(schema_p), move(view_p)), new_view_name(move(new_name_p)) {
+RenameViewInfo::RenameViewInfo(string schema_p, string view_p, bool if_exists_p, string new_name_p)
+    : AlterViewInfo(AlterViewType::RENAME_VIEW, move(schema_p), move(view_p), if_exists_p),
+      new_view_name(move(new_name_p)) {
 }
 RenameViewInfo::~RenameViewInfo() {
 }
 
 unique_ptr<AlterInfo> RenameViewInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameViewInfo>(schema, name, new_view_name);
+	return make_unique_base<AlterInfo, RenameViewInfo>(schema, name, if_exists, new_view_name);
 }
 
 void RenameViewInfo::SerializeAlterView(FieldWriter &writer) const {
 	writer.WriteString(new_view_name);
 }
 
-unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, string schema, string view) {
+unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, string schema, string view, bool if_exists) {
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameViewInfo>(move(schema), move(view), new_name);
+	return make_unique<RenameViewInfo>(move(schema), move(view), if_exists, new_name);
 }
 } // namespace duckdb
 
@@ -171802,10 +171834,6 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 }
 
 } // namespace duckdb
-
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -171831,6 +171859,10 @@ struct EnumClassHash {
 
 
 
+
+
+
+
 namespace duckdb {
 
 unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery::PGNode *node) {
@@ -171886,7 +171918,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 				throw InternalException("Wrong argument for %s. Expected either <schema>.<name> or <name>", opt_name);
 			}
 			auto info = make_unique<ChangeOwnershipInfo>(CatalogType::SEQUENCE_ENTRY, sequence_schema, sequence_name,
-			                                             owner_schema, owner_name);
+			                                             owner_schema, owner_name, stmt->missing_ok);
 			result->info = move(info);
 		} else {
 			throw NotImplementedException("ALTER SEQUENCE option not supported yet!");
@@ -171941,7 +171973,8 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 					throw ParserException("Adding columns with constraints not yet supported");
 				}
 			}
-			result->info = make_unique<AddColumnInfo>(qname.schema, qname.name, move(centry));
+			result->info = make_unique<AddColumnInfo>(qname.schema, qname.name, stmt->missing_ok, move(centry),
+			                                          command->missing_ok);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_DropColumn: {
@@ -171950,8 +171983,8 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
 				throw ParserException("Dropping columns is only supported for tables");
 			}
-			result->info =
-			    make_unique<RemoveColumnInfo>(qname.schema, qname.name, command->name, command->missing_ok, cascade);
+			result->info = make_unique<RemoveColumnInfo>(qname.schema, qname.name, stmt->missing_ok, command->name,
+			                                             command->missing_ok, cascade);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_ColumnDefault: {
@@ -171960,7 +171993,8 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
 				throw ParserException("Alter column's default is only supported for tables");
 			}
-			result->info = make_unique<SetDefaultInfo>(qname.schema, qname.name, command->name, move(expr));
+			result->info =
+			    make_unique<SetDefaultInfo>(qname.schema, qname.name, stmt->missing_ok, command->name, move(expr));
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_AlterColumnType: {
@@ -171977,16 +172011,16 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 				auto colref = make_unique<ColumnRefExpression>(command->name);
 				expr = make_unique<CastExpression>(column_definition.Type(), move(colref));
 			}
-			result->info = make_unique<ChangeColumnTypeInfo>(qname.schema, qname.name, command->name,
+			result->info = make_unique<ChangeColumnTypeInfo>(qname.schema, qname.name, stmt->missing_ok, command->name,
 			                                                 column_definition.Type(), move(expr));
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_SetNotNull: {
-			result->info = make_unique<SetNotNullInfo>(qname.schema, qname.name, command->name);
+			result->info = make_unique<SetNotNullInfo>(qname.schema, qname.name, stmt->missing_ok, command->name);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_DropNotNull: {
-			result->info = make_unique<DropNotNullInfo>(qname.schema, qname.name, command->name);
+			result->info = make_unique<DropNotNullInfo>(qname.schema, qname.name, stmt->missing_ok, command->name);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_DropConstraint:
@@ -171994,7 +172028,6 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 			throw NotImplementedException("ALTER TABLE option not supported yet!");
 		}
 	}
-	result->info->if_exists = stmt->missing_ok;
 
 	return result;
 }
@@ -173166,7 +173199,7 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 		// get the old name and the new name
 		string old_name = stmt->subname;
 		string new_name = stmt->newname;
-		info = make_unique<RenameColumnInfo>(schema, table, old_name, new_name);
+		info = make_unique<RenameColumnInfo>(schema, table, stmt->missing_ok, old_name, new_name);
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_TABLE: {
@@ -173183,7 +173216,7 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 			schema = stmt->relation->schemaname;
 		}
 		string new_name = stmt->newname;
-		info = make_unique<RenameTableInfo>(schema, table, new_name);
+		info = make_unique<RenameTableInfo>(schema, table, stmt->missing_ok, new_name);
 		break;
 	}
 
@@ -173201,7 +173234,7 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 			schema = stmt->relation->schemaname;
 		}
 		string new_name = stmt->newname;
-		info = make_unique<RenameViewInfo>(schema, view, new_name);
+		info = make_unique<RenameViewInfo>(schema, view, stmt->missing_ok, new_name);
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_DATABASE:
@@ -188565,6 +188598,10 @@ string PragmaHandler::HandlePragma(SQLStatement *statement) { // PragmaInfo &inf
 
 
 
+
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -188658,9 +188695,6 @@ public:
 } // namespace duckdb
 
 
-
-
-
 namespace duckdb {
 
 FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated,
@@ -189045,7 +189079,10 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		unique_ptr<Expression> condition;
 		auto row_num_ref =
 		    make_unique<BoundColumnRefExpression>(rownum_alias, LogicalType::BIGINT, ColumnBinding(window_index, 0));
-		auto upper_bound = make_unique<BoundConstantExpression>(Value::BIGINT(limit.offset_val + limit.limit_val));
+
+		int64_t upper_bound_limit = NumericLimits<int64_t>::Maximum();
+		TryAddOperator::Operation(limit.offset_val, limit.limit_val, upper_bound_limit);
+		auto upper_bound = make_unique<BoundConstantExpression>(Value::BIGINT(upper_bound_limit));
 		condition = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
 		                                                   row_num_ref->Copy(), move(upper_bound));
 		// we only need to add "row_number >= offset + 1" if offset is bigger than 0
@@ -208171,7 +208208,7 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 		for (idx_t i = 0; i < expr_count; i++) {
 			D_ASSERT(!select_list[i]->Equals(nullptr));
 			// Run the ToString, to verify that it doesn't crash
-			auto str = select_list[i]->ToString();
+			select_list[i]->ToString();
 
 			if (select_list[i]->HasSubquery()) {
 				continue;
@@ -208183,11 +208220,6 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 			D_ASSERT(select_list[i]->Hash() == other.select_list[i]->Hash());
 
 			other.select_list[i]->Verify();
-
-			// ToString round trip
-			auto parsed_list = Parser::ParseExpressionList(str);
-			D_ASSERT(parsed_list.size() == 1);
-			D_ASSERT(parsed_list[0]->Equals(select_list[i].get()));
 		}
 	}
 #endif