duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

package/src/duckdb/src/parser/parsed_data/alter_table_info.cpp

@@ -11,9 +11,10 @@ namespace duckdb {
 ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_catalog_p, string entry_schema_p,
                                          string entry_name_p, string owner_schema_p, string owner_name_p,
                                          bool if_exists)
-    : AlterInfo(AlterType::CHANGE_OWNERSHIP, move(entry_catalog_p), 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)) {
+    : AlterInfo(AlterType::CHANGE_OWNERSHIP, std::move(entry_catalog_p), std::move(entry_schema_p),
+                std::move(entry_name_p), if_exists),
+      entry_catalog_type(entry_catalog_type), owner_schema(std::move(owner_schema_p)),
+      owner_name(std::move(owner_name_p)) {
 }
 
 CatalogType ChangeOwnershipInfo::GetCatalogType() const {
@@ -33,7 +34,8 @@ void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
 AlterTableInfo::AlterTableInfo(AlterTableType type, AlterEntryData data)
-    : AlterInfo(AlterType::ALTER_TABLE, move(data.catalog), move(data.schema), move(data.name), data.if_exists),
+    : AlterInfo(AlterType::ALTER_TABLE, std::move(data.catalog), std::move(data.schema), std::move(data.name),
+                data.if_exists),
       alter_table_type(type) {
 }
 AlterTableInfo::~AlterTableInfo() {
@@ -63,23 +65,23 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 	unique_ptr<AlterTableInfo> info;
 	switch (type) {
 	case AlterTableType::RENAME_COLUMN:
-		return RenameColumnInfo::Deserialize(reader, move(data));
+		return RenameColumnInfo::Deserialize(reader, std::move(data));
 	case AlterTableType::RENAME_TABLE:
-		return RenameTableInfo::Deserialize(reader, move(data));
+		return RenameTableInfo::Deserialize(reader, std::move(data));
 	case AlterTableType::ADD_COLUMN:
-		return AddColumnInfo::Deserialize(reader, move(data));
+		return AddColumnInfo::Deserialize(reader, std::move(data));
 	case AlterTableType::REMOVE_COLUMN:
-		return RemoveColumnInfo::Deserialize(reader, move(data));
+		return RemoveColumnInfo::Deserialize(reader, std::move(data));
 	case AlterTableType::ALTER_COLUMN_TYPE:
-		return ChangeColumnTypeInfo::Deserialize(reader, move(data));
+		return ChangeColumnTypeInfo::Deserialize(reader, std::move(data));
 	case AlterTableType::SET_DEFAULT:
-		return SetDefaultInfo::Deserialize(reader, move(data));
+		return SetDefaultInfo::Deserialize(reader, std::move(data));
 	case AlterTableType::FOREIGN_KEY_CONSTRAINT:
-		return AlterForeignKeyInfo::Deserialize(reader, move(data));
+		return AlterForeignKeyInfo::Deserialize(reader, std::move(data));
 	case AlterTableType::SET_NOT_NULL:
-		return SetNotNullInfo::Deserialize(reader, move(data));
+		return SetNotNullInfo::Deserialize(reader, std::move(data));
 	case AlterTableType::DROP_NOT_NULL:
-		return DropNotNullInfo::Deserialize(reader, move(data));
+		return DropNotNullInfo::Deserialize(reader, std::move(data));
 	default:
 		throw SerializationException("Unknown alter table type for deserialization!");
 	}
@@ -89,8 +91,8 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 // RenameColumnInfo
 //===--------------------------------------------------------------------===//
 RenameColumnInfo::RenameColumnInfo(AlterEntryData data, string old_name_p, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_COLUMN, move(data)), old_name(move(old_name_p)),
-      new_name(move(new_name_p)) {
+    : AlterTableInfo(AlterTableType::RENAME_COLUMN, std::move(data)), old_name(std::move(old_name_p)),
+      new_name(std::move(new_name_p)) {
 }
 RenameColumnInfo::~RenameColumnInfo() {
 }
@@ -107,14 +109,14 @@ void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto old_name = reader.ReadRequired<string>();
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameColumnInfo>(move(data), old_name, new_name);
+	return make_unique<RenameColumnInfo>(std::move(data), old_name, new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
 RenameTableInfo::RenameTableInfo(AlterEntryData data, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_TABLE, move(data)), new_table_name(move(new_name_p)) {
+    : AlterTableInfo(AlterTableType::RENAME_TABLE, std::move(data)), new_table_name(std::move(new_name_p)) {
 }
 RenameTableInfo::~RenameTableInfo() {
 }
@@ -129,14 +131,14 @@ void RenameTableInfo::SerializeAlterTable(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameTableInfo>(move(data), new_name);
+	return make_unique<RenameTableInfo>(std::move(data), new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
 AddColumnInfo::AddColumnInfo(AlterEntryData data, ColumnDefinition new_column, bool if_column_not_exists)
-    : AlterTableInfo(AlterTableType::ADD_COLUMN, move(data)), new_column(move(new_column)),
+    : AlterTableInfo(AlterTableType::ADD_COLUMN, std::move(data)), new_column(std::move(new_column)),
       if_column_not_exists(if_column_not_exists) {
 }
 
@@ -155,14 +157,14 @@ void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_column = reader.ReadRequiredSerializable<ColumnDefinition, ColumnDefinition>();
 	auto if_column_not_exists = reader.ReadRequired<bool>();
-	return make_unique<AddColumnInfo>(move(data), move(new_column), if_column_not_exists);
+	return make_unique<AddColumnInfo>(std::move(data), std::move(new_column), if_column_not_exists);
 }
 
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
 RemoveColumnInfo::RemoveColumnInfo(AlterEntryData data, string removed_column, bool if_column_exists, bool cascade)
-    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, move(data)), removed_column(move(removed_column)),
+    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, std::move(data)), removed_column(std::move(removed_column)),
       if_column_exists(if_column_exists), cascade(cascade) {
 }
 RemoveColumnInfo::~RemoveColumnInfo() {
@@ -183,7 +185,7 @@ unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, AlterEn
 	auto new_name = reader.ReadRequired<string>();
 	auto if_column_exists = reader.ReadRequired<bool>();
 	auto cascade = reader.ReadRequired<bool>();
-	return make_unique<RemoveColumnInfo>(move(data), move(new_name), if_column_exists, cascade);
+	return make_unique<RemoveColumnInfo>(std::move(data), std::move(new_name), if_column_exists, cascade);
 }
 
 //===--------------------------------------------------------------------===//
@@ -191,8 +193,8 @@ unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, AlterEn
 //===--------------------------------------------------------------------===//
 ChangeColumnTypeInfo::ChangeColumnTypeInfo(AlterEntryData data, string column_name, LogicalType target_type,
                                            unique_ptr<ParsedExpression> expression)
-    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, move(data)), column_name(move(column_name)),
-      target_type(move(target_type)), expression(move(expression)) {
+    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, std::move(data)), column_name(std::move(column_name)),
+      target_type(std::move(target_type)), expression(std::move(expression)) {
 }
 ChangeColumnTypeInfo::~ChangeColumnTypeInfo() {
 }
@@ -212,15 +214,16 @@ unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, Alt
 	auto column_name = reader.ReadRequired<string>();
 	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<ChangeColumnTypeInfo>(move(data), move(column_name), move(target_type), move(expression));
+	return make_unique<ChangeColumnTypeInfo>(std::move(data), std::move(column_name), std::move(target_type),
+	                                         std::move(expression));
 }
 
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
 SetDefaultInfo::SetDefaultInfo(AlterEntryData data, string column_name_p, unique_ptr<ParsedExpression> new_default)
-    : AlterTableInfo(AlterTableType::SET_DEFAULT, move(data)), column_name(move(column_name_p)),
-      expression(move(new_default)) {
+    : AlterTableInfo(AlterTableType::SET_DEFAULT, std::move(data)), column_name(std::move(column_name_p)),
+      expression(std::move(new_default)) {
 }
 SetDefaultInfo::~SetDefaultInfo() {
 }
@@ -238,14 +241,14 @@ void SetDefaultInfo::SerializeAlterTable(FieldWriter &writer) const {
 unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
 	auto new_default = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<SetDefaultInfo>(move(data), move(column_name), move(new_default));
+	return make_unique<SetDefaultInfo>(std::move(data), std::move(column_name), std::move(new_default));
 }
 
 //===--------------------------------------------------------------------===//
 // SetNotNullInfo
 //===--------------------------------------------------------------------===//
 SetNotNullInfo::SetNotNullInfo(AlterEntryData data, string column_name_p)
-    : AlterTableInfo(AlterTableType::SET_NOT_NULL, move(data)), column_name(move(column_name_p)) {
+    : AlterTableInfo(AlterTableType::SET_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
 }
 SetNotNullInfo::~SetNotNullInfo() {
 }
@@ -260,14 +263,14 @@ void SetNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
-	return make_unique<SetNotNullInfo>(move(data), move(column_name));
+	return make_unique<SetNotNullInfo>(std::move(data), std::move(column_name));
 }
 
 //===--------------------------------------------------------------------===//
 // DropNotNullInfo
 //===--------------------------------------------------------------------===//
 DropNotNullInfo::DropNotNullInfo(AlterEntryData data, string column_name_p)
-    : AlterTableInfo(AlterTableType::DROP_NOT_NULL, move(data)), column_name(move(column_name_p)) {
+    : AlterTableInfo(AlterTableType::DROP_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
 }
 DropNotNullInfo::~DropNotNullInfo() {
 }
@@ -282,7 +285,7 @@ void DropNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
-	return make_unique<DropNotNullInfo>(move(data), move(column_name));
+	return make_unique<DropNotNullInfo>(std::move(data), std::move(column_name));
 }
 
 //===--------------------------------------------------------------------===//
@@ -291,9 +294,9 @@ unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, AlterEnt
 AlterForeignKeyInfo::AlterForeignKeyInfo(AlterEntryData data, string fk_table, vector<string> pk_columns,
                                          vector<string> fk_columns, vector<PhysicalIndex> pk_keys,
                                          vector<PhysicalIndex> fk_keys, AlterForeignKeyType type_p)
-    : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT, move(data)), 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) {
+    : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT, std::move(data)), fk_table(std::move(fk_table)),
+      pk_columns(std::move(pk_columns)), fk_columns(std::move(fk_columns)), pk_keys(std::move(pk_keys)),
+      fk_keys(std::move(fk_keys)), type(type_p) {
 }
 AlterForeignKeyInfo::~AlterForeignKeyInfo() {
 }
@@ -319,15 +322,16 @@ unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, Alte
 	auto pk_keys = reader.ReadRequiredIndexList<PhysicalIndex>();
 	auto fk_keys = reader.ReadRequiredIndexList<PhysicalIndex>();
 	auto type = reader.ReadRequired<AlterForeignKeyType>();
-	return make_unique<AlterForeignKeyInfo>(move(data), move(fk_table), move(pk_columns), move(fk_columns),
-	                                        move(pk_keys), move(fk_keys), type);
+	return make_unique<AlterForeignKeyInfo>(std::move(data), std::move(fk_table), std::move(pk_columns),
+	                                        std::move(fk_columns), std::move(pk_keys), std::move(fk_keys), type);
 }
 
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
 AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
-    : AlterInfo(AlterType::ALTER_VIEW, move(data.catalog), move(data.schema), move(data.name), data.if_exists),
+    : AlterInfo(AlterType::ALTER_VIEW, std::move(data.catalog), std::move(data.schema), std::move(data.name),
+                data.if_exists),
       alter_view_type(type) {
 }
 AlterViewInfo::~AlterViewInfo() {
@@ -356,7 +360,7 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 	unique_ptr<AlterViewInfo> info;
 	switch (type) {
 	case AlterViewType::RENAME_VIEW:
-		return RenameViewInfo::Deserialize(reader, move(data));
+		return RenameViewInfo::Deserialize(reader, std::move(data));
 	default:
 		throw SerializationException("Unknown alter view type for deserialization!");
 	}
@@ -366,7 +370,7 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
 RenameViewInfo::RenameViewInfo(AlterEntryData data, string new_name_p)
-    : AlterViewInfo(AlterViewType::RENAME_VIEW, move(data)), new_view_name(move(new_name_p)) {
+    : AlterViewInfo(AlterViewType::RENAME_VIEW, std::move(data)), new_view_name(std::move(new_name_p)) {
 }
 RenameViewInfo::~RenameViewInfo() {
 }
@@ -381,6 +385,6 @@ void RenameViewInfo::SerializeAlterView(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameViewInfo>(move(data), new_name);
+	return make_unique<RenameViewInfo>(std::move(data), new_name);
 }
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_aggregate_function_info.cpp

@@ -5,12 +5,12 @@ namespace duckdb {
 CreateAggregateFunctionInfo::CreateAggregateFunctionInfo(AggregateFunction function)
     : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
 	name = function.name;
-	functions.AddFunction(move(function));
+	functions.AddFunction(std::move(function));
 	internal = true;
 }
 
 CreateAggregateFunctionInfo::CreateAggregateFunctionInfo(AggregateFunctionSet set)
-    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
+    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(std::move(set)) {
 	name = functions.name;
 	for (auto &func : functions.functions) {
 		func.name = functions.name;
@@ -21,7 +21,7 @@ CreateAggregateFunctionInfo::CreateAggregateFunctionInfo(AggregateFunctionSet se
 unique_ptr<CreateInfo> CreateAggregateFunctionInfo::Copy() const {
 	auto result = make_unique<CreateAggregateFunctionInfo>(functions);
 	CopyProperties(*result);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_collation_info.cpp

@@ -4,9 +4,9 @@ namespace duckdb {
 
 CreateCollationInfo::CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p,
                                          bool not_required_for_equality_p)
-    : CreateInfo(CatalogType::COLLATION_ENTRY), function(move(function_p)), combinable(combinable_p),
+    : CreateInfo(CatalogType::COLLATION_ENTRY), function(std::move(function_p)), combinable(combinable_p),
       not_required_for_equality(not_required_for_equality_p) {
-	this->name = move(name_p);
+	this->name = std::move(name_p);
 	internal = true;
 }
 
@@ -17,7 +17,7 @@ void CreateCollationInfo::SerializeInternal(Serializer &) const {
 unique_ptr<CreateInfo> CreateCollationInfo::Copy() const {
 	auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
 	CopyProperties(*result);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_copy_function_info.cpp

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 CreateCopyFunctionInfo::CreateCopyFunctionInfo(CopyFunction function_p)
-    : CreateInfo(CatalogType::COPY_FUNCTION_ENTRY), function(move(function_p)) {
+    : CreateInfo(CatalogType::COPY_FUNCTION_ENTRY), function(std::move(function_p)) {
 	this->name = function.name;
 	internal = true;
 }
@@ -15,7 +15,7 @@ void CreateCopyFunctionInfo::SerializeInternal(Serializer &) const {
 unique_ptr<CreateInfo> CreateCopyFunctionInfo::Copy() const {
 	auto result = make_unique<CreateCopyFunctionInfo>(function);
 	CopyProperties(*result);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_index_info.cpp

@@ -20,7 +20,7 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	result->scan_types = scan_types;
 	result->names = names;
 	result->column_ids = column_ids;
-	return move(result);
+	return std::move(result);
 }
 
 void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {

package/src/duckdb/src/parser/parsed_data/create_info.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/parser/parsed_data/create_schema_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/create_database_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
 
 namespace duckdb {
@@ -38,6 +39,8 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 		return CreateSchemaInfo::Deserialize(deserializer);
 	case CatalogType::VIEW_ENTRY:
 		return CreateViewInfo::Deserialize(deserializer);
+	case CatalogType::DATABASE_ENTRY:
+		return CreateDatabaseInfo::Deserialize(deserializer);
 	default:
 		throw NotImplementedException("Cannot deserialize '%s'", CatalogTypeToString(type));
 	}

package/src/duckdb/src/parser/parsed_data/create_pragma_function_info.cpp

@@ -5,19 +5,19 @@ namespace duckdb {
 CreatePragmaFunctionInfo::CreatePragmaFunctionInfo(PragmaFunction function)
     : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(function.name) {
 	name = function.name;
-	functions.AddFunction(move(function));
+	functions.AddFunction(std::move(function));
 	internal = true;
 }
 CreatePragmaFunctionInfo::CreatePragmaFunctionInfo(string name, PragmaFunctionSet functions_p)
-    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(move(functions_p)) {
-	this->name = move(name);
+    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(std::move(functions_p)) {
+	this->name = std::move(name);
 	internal = true;
 }
 
 unique_ptr<CreateInfo> CreatePragmaFunctionInfo::Copy() const {
 	auto result = make_unique<CreatePragmaFunctionInfo>(functions.name, functions);
 	CopyProperties(*result);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_scalar_function_info.cpp

@@ -6,11 +6,11 @@ namespace duckdb {
 CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunction function)
     : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(function.name) {
 	name = function.name;
-	functions.AddFunction(move(function));
+	functions.AddFunction(std::move(function));
 	internal = true;
 }
 CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunctionSet set)
-    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(move(set)) {
+    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(std::move(set)) {
 	name = functions.name;
 	for (auto &func : functions.functions) {
 		func.name = functions.name;
@@ -21,9 +21,9 @@ CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunctionSet set)
 unique_ptr<CreateInfo> CreateScalarFunctionInfo::Copy() const {
 	ScalarFunctionSet set(name);
 	set.functions = functions.functions;
-	auto result = make_unique<CreateScalarFunctionInfo>(move(set));
+	auto result = make_unique<CreateScalarFunctionInfo>(std::move(set));
 	CopyProperties(*result);
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<AlterInfo> CreateScalarFunctionInfo::GetAlterInfo() const {

package/src/duckdb/src/parser/parsed_data/create_table_function_info.cpp

@@ -5,11 +5,11 @@ namespace duckdb {
 CreateTableFunctionInfo::CreateTableFunctionInfo(TableFunction function)
     : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(function.name) {
 	name = function.name;
-	functions.AddFunction(move(function));
+	functions.AddFunction(std::move(function));
 	internal = true;
 }
 CreateTableFunctionInfo::CreateTableFunctionInfo(TableFunctionSet set)
-    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(move(set)) {
+    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(std::move(set)) {
 	name = functions.name;
 	for (auto &func : functions.functions) {
 		func.name = functions.name;
@@ -20,9 +20,9 @@ CreateTableFunctionInfo::CreateTableFunctionInfo(TableFunctionSet set)
 unique_ptr<CreateInfo> CreateTableFunctionInfo::Copy() const {
 	TableFunctionSet set(name);
 	set.functions = functions.functions;
-	auto result = make_unique<CreateTableFunctionInfo>(move(set));
+	auto result = make_unique<CreateTableFunctionInfo>(std::move(set));
 	CopyProperties(*result);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_table_info.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog.hpp"
 
 namespace duckdb {
@@ -8,11 +9,11 @@ CreateTableInfo::CreateTableInfo() : CreateInfo(CatalogType::TABLE_ENTRY, INVALI
 }
 
 CreateTableInfo::CreateTableInfo(string catalog_p, string schema_p, string name_p)
-    : CreateInfo(CatalogType::TABLE_ENTRY, move(schema_p), move(catalog_p)), table(move(name_p)) {
+    : CreateInfo(CatalogType::TABLE_ENTRY, std::move(schema_p), std::move(catalog_p)), table(std::move(name_p)) {
 }
 
 CreateTableInfo::CreateTableInfo(SchemaCatalogEntry *schema, string name_p)
-    : CreateTableInfo(schema->catalog->GetName(), schema->name, move(name_p)) {
+    : CreateTableInfo(schema->catalog->GetName(), schema->name, std::move(name_p)) {
 }
 
 void CreateTableInfo::SerializeInternal(Serializer &serializer) const {
@@ -48,7 +49,7 @@ unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
 	if (query) {
 		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
 	}
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_view_info.cpp

@@ -1,17 +1,22 @@
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/parser/parser.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/parser/statement/create_statement.hpp"
 
 namespace duckdb {
 
 CreateViewInfo::CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
 }
 CreateViewInfo::CreateViewInfo(string catalog_p, string schema_p, string view_name_p)
-    : CreateInfo(CatalogType::VIEW_ENTRY, move(schema_p), move(catalog_p)), view_name(move(view_name_p)) {
+    : CreateInfo(CatalogType::VIEW_ENTRY, std::move(schema_p), std::move(catalog_p)),
+      view_name(std::move(view_name_p)) {
 }
 
 CreateViewInfo::CreateViewInfo(SchemaCatalogEntry *schema, string view_name)
-    : CreateViewInfo(schema->catalog->GetName(), schema->name, move(view_name)) {
+    : CreateViewInfo(schema->catalog->GetName(), schema->name, std::move(view_name)) {
 }
 
 unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
@@ -20,7 +25,7 @@ unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
 	result->aliases = aliases;
 	result->types = types;
 	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<CreateViewInfo> CreateViewInfo::Deserialize(Deserializer &deserializer) {
@@ -46,4 +51,52 @@ void CreateViewInfo::SerializeInternal(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+unique_ptr<CreateViewInfo> CreateViewInfo::FromSelect(ClientContext &context, unique_ptr<CreateViewInfo> info) {
+	D_ASSERT(info);
+	D_ASSERT(!info->view_name.empty());
+	D_ASSERT(!info->sql.empty());
+	D_ASSERT(!info->query);
+
+	Parser parser;
+	parser.ParseQuery(info->sql);
+	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
+		throw BinderException(
+		    "Failed to create view from SQL string - \"%s\" - statement did not contain a single SELECT statement",
+		    info->sql);
+	}
+	D_ASSERT(parser.statements.size() == 1 && parser.statements[0]->type == StatementType::SELECT_STATEMENT);
+	info->query = unique_ptr_cast<SQLStatement, SelectStatement>(std::move(parser.statements[0]));
+
+	auto binder = Binder::CreateBinder(context);
+	binder->BindCreateViewInfo(*info);
+
+	return info;
+}
+
+unique_ptr<CreateViewInfo> CreateViewInfo::FromCreateView(ClientContext &context, const string &sql) {
+	D_ASSERT(!sql.empty());
+
+	// parse the SQL statement
+	Parser parser;
+	parser.ParseQuery(sql);
+
+	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
+		throw BinderException(
+		    "Failed to create view from SQL string - \"%s\" - statement did not contain a single CREATE VIEW statement",
+		    sql);
+	}
+	auto &create_statement = (CreateStatement &)*parser.statements[0];
+	if (create_statement.info->type != CatalogType::VIEW_ENTRY) {
+		throw BinderException(
+		    "Failed to create view from SQL string - \"%s\" - view did not contain a CREATE VIEW statement", sql);
+	}
+
+	auto result = unique_ptr_cast<CreateInfo, CreateViewInfo>(std::move(create_statement.info));
+
+	auto binder = Binder::CreateBinder(context);
+	binder->BindCreateViewInfo(*result);
+
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_expression.cpp

@@ -52,40 +52,40 @@ bool ParsedExpression::Equals(const BaseExpression *other) const {
 	}
 	switch (expression_class) {
 	case ExpressionClass::BETWEEN:
-		return BetweenExpression::Equals((BetweenExpression *)this, (BetweenExpression *)other);
+		return BetweenExpression::Equal((BetweenExpression *)this, (BetweenExpression *)other);
 	case ExpressionClass::CASE:
-		return CaseExpression::Equals((CaseExpression *)this, (CaseExpression *)other);
+		return CaseExpression::Equal((CaseExpression *)this, (CaseExpression *)other);
 	case ExpressionClass::CAST:
-		return CastExpression::Equals((CastExpression *)this, (CastExpression *)other);
+		return CastExpression::Equal((CastExpression *)this, (CastExpression *)other);
 	case ExpressionClass::COLLATE:
-		return CollateExpression::Equals((CollateExpression *)this, (CollateExpression *)other);
+		return CollateExpression::Equal((CollateExpression *)this, (CollateExpression *)other);
 	case ExpressionClass::COLUMN_REF:
-		return ColumnRefExpression::Equals((ColumnRefExpression *)this, (ColumnRefExpression *)other);
+		return ColumnRefExpression::Equal((ColumnRefExpression *)this, (ColumnRefExpression *)other);
 	case ExpressionClass::COMPARISON:
-		return ComparisonExpression::Equals((ComparisonExpression *)this, (ComparisonExpression *)other);
+		return ComparisonExpression::Equal((ComparisonExpression *)this, (ComparisonExpression *)other);
 	case ExpressionClass::CONJUNCTION:
-		return ConjunctionExpression::Equals((ConjunctionExpression *)this, (ConjunctionExpression *)other);
+		return ConjunctionExpression::Equal((ConjunctionExpression *)this, (ConjunctionExpression *)other);
 	case ExpressionClass::CONSTANT:
-		return ConstantExpression::Equals((ConstantExpression *)this, (ConstantExpression *)other);
+		return ConstantExpression::Equal((ConstantExpression *)this, (ConstantExpression *)other);
 	case ExpressionClass::DEFAULT:
 		return true;
 	case ExpressionClass::FUNCTION:
-		return FunctionExpression::Equals((FunctionExpression *)this, (FunctionExpression *)other);
+		return FunctionExpression::Equal((FunctionExpression *)this, (FunctionExpression *)other);
 	case ExpressionClass::LAMBDA:
-		return LambdaExpression::Equals((LambdaExpression *)this, (LambdaExpression *)other);
+		return LambdaExpression::Equal((LambdaExpression *)this, (LambdaExpression *)other);
 	case ExpressionClass::OPERATOR:
-		return OperatorExpression::Equals((OperatorExpression *)this, (OperatorExpression *)other);
+		return OperatorExpression::Equal((OperatorExpression *)this, (OperatorExpression *)other);
 	case ExpressionClass::PARAMETER:
-		return ParameterExpression::Equals((ParameterExpression *)this, (ParameterExpression *)other);
+		return ParameterExpression::Equal((ParameterExpression *)this, (ParameterExpression *)other);
 	case ExpressionClass::POSITIONAL_REFERENCE:
-		return PositionalReferenceExpression::Equals((PositionalReferenceExpression *)this,
-		                                             (PositionalReferenceExpression *)other);
+		return PositionalReferenceExpression::Equal((PositionalReferenceExpression *)this,
+		                                            (PositionalReferenceExpression *)other);
 	case ExpressionClass::STAR:
-		return StarExpression::Equals((StarExpression *)this, (StarExpression *)other);
+		return StarExpression::Equal((StarExpression *)this, (StarExpression *)other);
 	case ExpressionClass::SUBQUERY:
-		return SubqueryExpression::Equals((SubqueryExpression *)this, (SubqueryExpression *)other);
+		return SubqueryExpression::Equal((SubqueryExpression *)this, (SubqueryExpression *)other);
 	case ExpressionClass::WINDOW:
-		return WindowExpression::Equals((WindowExpression *)this, (WindowExpression *)other);
+		return WindowExpression::Equal((WindowExpression *)this, (WindowExpression *)other);
 	default:
 		throw SerializationException("Unsupported type for expression comparison!");
 	}

package/src/duckdb/src/parser/parsed_expression_iterator.cpp

@@ -195,12 +195,6 @@ void ParsedExpressionIterator::EnumerateQueryNodeModifiers(
 void ParsedExpressionIterator::EnumerateTableRefChildren(
     TableRef &ref, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
 	switch (ref.type) {
-	case TableReferenceType::CROSS_PRODUCT: {
-		auto &cp_ref = (CrossProductRef &)ref;
-		EnumerateTableRefChildren(*cp_ref.left, callback);
-		EnumerateTableRefChildren(*cp_ref.right, callback);
-		break;
-	}
 	case TableReferenceType::EXPRESSION_LIST: {
 		auto &el_ref = (ExpressionListRef &)ref;
 		for (idx_t i = 0; i < el_ref.values.size(); i++) {
@@ -233,7 +227,8 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 	case TableReferenceType::EMPTY:
 		// these TableRefs do not need to be unfolded
 		break;
-	default:
+	case TableReferenceType::INVALID:
+	case TableReferenceType::CTE:
 		throw NotImplementedException("TableRef type not implemented for traversal");
 	}
 }