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

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_schema_info.hpp

@@ -20,7 +20,7 @@ public:
 	unique_ptr<CreateInfo> Copy() const override {
 		auto result = make_unique<CreateSchemaInfo>();
 		CopyProperties(*result);
-		return move(result);
+		return std::move(result);
 	}
 
 	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &deserializer) {

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_sequence_info.hpp

@@ -61,7 +61,7 @@ public:
 		result->max_value = max_value;
 		result->start_value = start_value;
 		result->cycle = cycle;
-		return move(result);
+		return std::move(result);
 	}
 
 protected:

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp

@@ -19,7 +19,7 @@ struct CreateTypeInfo : public CreateInfo {
 	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
 	}
 	CreateTypeInfo(string name_p, LogicalType type_p)
-	    : CreateInfo(CatalogType::TYPE_ENTRY), name(move(name_p)), type(move(type_p)) {
+	    : CreateInfo(CatalogType::TYPE_ENTRY), name(std::move(name_p)), type(std::move(type_p)) {
 	}
 
 	//! Name of the Type
@@ -38,7 +38,7 @@ public:
 		if (query) {
 			result->query = query->Copy();
 		}
-		return move(result);
+		return std::move(result);
 	}
 
 protected:

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp

@@ -33,6 +33,11 @@ public:
 
 	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &deserializer);
 
+	//! Gets a bound CreateViewInfo object from a SELECT statement and a view name, schema name, etc
+	DUCKDB_API static unique_ptr<CreateViewInfo> FromSelect(ClientContext &context, unique_ptr<CreateViewInfo> info);
+	//! Gets a bound CreateViewInfo object from a CREATE VIEW statement
+	DUCKDB_API static unique_ptr<CreateViewInfo> FromCreateView(ClientContext &context, const string &sql);
+
 protected:
 	void SerializeInternal(Serializer &serializer) const override;
 };

package/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp

@@ -8,8 +8,9 @@
 
 #pragma once
 
-#include "duckdb/parser/parsed_data/parse_info.hpp"
 #include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/parser/parsed_data/parse_info.hpp"
 
 namespace duckdb {
 
@@ -45,6 +46,32 @@ public:
 		result->allow_drop_internal = allow_drop_internal;
 		return result;
 	}
+
+	void Serialize(Serializer &serializer) const {
+		FieldWriter writer(serializer);
+		writer.WriteField<CatalogType>(type);
+		writer.WriteString(catalog);
+		writer.WriteString(schema);
+		writer.WriteString(name);
+		writer.WriteField(if_exists);
+		writer.WriteField(cascade);
+		writer.WriteField(allow_drop_internal);
+		writer.Finalize();
+	}
+
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer) {
+		FieldReader reader(deserializer);
+		auto drop_info = make_unique<DropInfo>();
+		drop_info->type = reader.ReadRequired<CatalogType>();
+		drop_info->catalog = reader.ReadRequired<string>();
+		drop_info->schema = reader.ReadRequired<string>();
+		drop_info->name = reader.ReadRequired<string>();
+		drop_info->if_exists = reader.ReadRequired<bool>();
+		drop_info->cascade = reader.ReadRequired<bool>();
+		drop_info->allow_drop_internal = reader.ReadRequired<bool>();
+		reader.Finalize();
+		return std::move(drop_info);
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/load_info.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/parsed_data/parse_info.hpp"
 
 namespace duckdb {
@@ -25,6 +26,22 @@ public:
 		result->load_type = load_type;
 		return result;
 	}
+
+	void Serialize(Serializer &serializer) const {
+		FieldWriter writer(serializer);
+		writer.WriteString(filename);
+		writer.WriteField<LoadType>(load_type);
+		writer.Finalize();
+	}
+
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer) {
+		FieldReader reader(deserializer);
+		auto load_info = make_unique<LoadInfo>();
+		load_info->filename = reader.ReadRequired<string>();
+		load_info->load_type = reader.ReadRequired<LoadType>();
+		reader.Finalize();
+		return std::move(load_info);
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parser_extension.hpp

@@ -39,10 +39,10 @@ struct ParserExtensionParseResult {
 	ParserExtensionParseResult() : type(ParserExtensionResultType::DISPLAY_ORIGINAL_ERROR) {
 	}
 	ParserExtensionParseResult(string error_p)
-	    : type(ParserExtensionResultType::DISPLAY_EXTENSION_ERROR), error(move(error_p)) {
+	    : type(ParserExtensionResultType::DISPLAY_EXTENSION_ERROR), error(std::move(error_p)) {
 	}
 	ParserExtensionParseResult(unique_ptr<ParserExtensionParseData> parse_data_p)
-	    : type(ParserExtensionResultType::PARSE_SUCCESSFUL), parse_data(move(parse_data_p)) {
+	    : type(ParserExtensionResultType::PARSE_SUCCESSFUL), parse_data(std::move(parse_data_p)) {
 	}
 
 	//! Whether or not parsing was successful

package/src/duckdb/src/include/duckdb/parser/qualified_name.hpp

@@ -80,7 +80,7 @@ struct QualifiedName {
 struct QualifiedColumnName {
 	QualifiedColumnName() {
 	}
-	QualifiedColumnName(string table_p, string column_p) : table(move(table_p)), column(move(column_p)) {
+	QualifiedColumnName(string table_p, string column_p) : table(std::move(table_p)), column(std::move(column_p)) {
 	}
 
 	string schema;

package/src/duckdb/src/include/duckdb/parser/result_modifier.hpp

@@ -51,7 +51,7 @@ public:
 //! Single node in ORDER BY statement
 struct OrderByNode {
 	OrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<ParsedExpression> expression)
-	    : type(type), null_order(null_order), expression(move(expression)) {
+	    : type(type), null_order(null_order), expression(std::move(expression)) {
 	}
 
 	//! Sort order, ASC or DESC

package/src/duckdb/src/include/duckdb/parser/statement/copy_statement.hpp

@@ -21,11 +21,15 @@ public:
 	unique_ptr<CopyInfo> info;
 	// The SQL statement used instead of a table when copying data out to a file
 	unique_ptr<QueryNode> select_statement;
+	string ToString() const override;
+	string CopyOptionsToString(const string &format, const case_insensitive_map_t<vector<Value>> &options) const;
 
 protected:
 	CopyStatement(const CopyStatement &other);
 
 public:
 	unique_ptr<SQLStatement> Copy() const override;
+
+private:
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/statement/insert_statement.hpp

@@ -11,9 +11,38 @@
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/query_node.hpp"
+#include "duckdb/parser/statement/update_statement.hpp"
 
 namespace duckdb {
 class ExpressionListRef;
+class UpdateSetInfo;
+
+enum class OnConflictAction : uint8_t {
+	THROW,
+	NOTHING,
+	UPDATE,
+	REPLACE // Only used in transform/bind step, changed to UPDATE later
+};
+
+class OnConflictInfo {
+public:
+	OnConflictInfo();
+
+public:
+	unique_ptr<OnConflictInfo> Copy() const;
+
+public:
+	OnConflictAction action_type;
+
+	vector<string> indexed_columns;
+	//! The SET information (if action_type == UPDATE)
+	unique_ptr<UpdateSetInfo> set_info;
+	//! The condition determining whether we apply the DO .. for conflicts that arise
+	unique_ptr<ParsedExpression> condition;
+
+protected:
+	OnConflictInfo(const OnConflictInfo &other);
+};
 
 class InsertStatement : public SQLStatement {
 public:
@@ -34,6 +63,9 @@ public:
 	//! keep track of optional returningList if statement contains a RETURNING keyword
 	vector<unique_ptr<ParsedExpression>> returning_list;
 
+	unique_ptr<OnConflictInfo> on_conflict_info;
+	unique_ptr<TableRef> table_ref;
+
 	//! CTEs
 	CommonTableExpressionMap cte_map;
 
@@ -41,6 +73,7 @@ protected:
 	InsertStatement(const InsertStatement &other);
 
 public:
+	static string OnConflictActionToString(OnConflictAction action);
 	string ToString() const override;
 	unique_ptr<SQLStatement> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/statement/logical_plan_statement.hpp

@@ -16,7 +16,7 @@ namespace duckdb {
 class LogicalPlanStatement : public SQLStatement {
 public:
 	explicit LogicalPlanStatement(unique_ptr<LogicalOperator> plan_p)
-	    : SQLStatement(StatementType::LOGICAL_PLAN_STATEMENT), plan(move(plan_p)) {};
+	    : SQLStatement(StatementType::LOGICAL_PLAN_STATEMENT), plan(std::move(plan_p)) {};
 
 	unique_ptr<LogicalOperator> plan;
 

package/src/duckdb/src/include/duckdb/parser/statement/update_statement.hpp

@@ -16,17 +16,34 @@
 
 namespace duckdb {
 
+class UpdateSetInfo {
+public:
+	UpdateSetInfo();
+
+public:
+	unique_ptr<UpdateSetInfo> Copy() const;
+
+public:
+	// The condition that needs to be met to perform the update
+	unique_ptr<ParsedExpression> condition;
+	// The columns to update
+	vector<string> columns;
+	// The set expressions to execute
+	vector<unique_ptr<ParsedExpression>> expressions;
+
+protected:
+	UpdateSetInfo(const UpdateSetInfo &other);
+};
+
 class UpdateStatement : public SQLStatement {
 public:
 	UpdateStatement();
 
-	unique_ptr<ParsedExpression> condition;
 	unique_ptr<TableRef> table;
 	unique_ptr<TableRef> from_table;
-	vector<string> columns;
-	vector<unique_ptr<ParsedExpression>> expressions;
 	//! keep track of optional returningList if statement contains a RETURNING keyword
 	vector<unique_ptr<ParsedExpression>> returning_list;
+	unique_ptr<UpdateSetInfo> set_info;
 	//! CTEs
 	CommonTableExpressionMap cte_map;
 

package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp

@@ -9,16 +9,19 @@
 #pragma once
 
 #include "duckdb/common/enums/join_type.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/tableref.hpp"
 #include "duckdb/common/vector.hpp"
 
 namespace duckdb {
+
 //! Represents a JOIN between two expressions
 class JoinRef : public TableRef {
 public:
-	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
+	explicit JoinRef(JoinRefType ref_type)
+	    : TableRef(TableReferenceType::JOIN), type(JoinType::INNER), ref_type(ref_type) {
 	}
 
 	//! The left hand side of the join
@@ -29,8 +32,8 @@ public:
 	unique_ptr<ParsedExpression> condition;
 	//! The join type
 	JoinType type;
-	//! Natural join
-	bool is_natural;
+	//! Join condition type
+	JoinRefType ref_type;
 	//! The set of USING columns (if any)
 	vector<string> using_columns;
 

package/src/duckdb/src/include/duckdb/parser/tableref/list.hpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/tableref/crossproductref.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"

package/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp

@@ -26,7 +26,7 @@ public:
 	// if the function takes a subquery as argument its in here
 	unique_ptr<SelectStatement> subquery;
 
-	// External dependencies of this table funcion
+	// External dependencies of this table function
 	unique_ptr<ExternalDependency> external_dependency;
 
 public:

package/src/duckdb/src/include/duckdb/parser/tokens.hpp

@@ -88,7 +88,6 @@ class ForeignKeyConstraint;
 class TableRef;
 
 class BaseTableRef;
-class CrossProductRef;
 class JoinRef;
 class SubqueryRef;
 class TableFunctionRef;

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -30,6 +30,8 @@ struct OrderByNode;
 struct CopyInfo;
 struct CommonTableExpressionInfo;
 struct GroupingExpressionMap;
+class OnConflictInfo;
+class UpdateSetInfo;
 
 //! The transformer class is responsible for transforming the internal Postgres
 //! parser representation into the DuckDB representation
@@ -119,12 +121,21 @@ private:
 	unique_ptr<CreateStatement> TransformCreateFunction(duckdb_libpgquery::PGNode *node);
 	//! Transform a Postgres duckdb_libpgquery::T_PGCreateTypeStmt node into CreateStatement
 	unique_ptr<CreateStatement> TransformCreateType(duckdb_libpgquery::PGNode *node);
+	//! Transform a Postgres duckdb_libpgquery::T_PGCreateDatabaseStmt node into a CreateStatement
+	unique_ptr<CreateStatement> TransformCreateDatabase(duckdb_libpgquery::PGNode *node);
 	//! Transform a Postgres duckdb_libpgquery::T_PGAlterSeqStmt node into CreateStatement
 	unique_ptr<AlterStatement> TransformAlterSequence(duckdb_libpgquery::PGNode *node);
 	//! Transform a Postgres duckdb_libpgquery::T_PGDropStmt node into a Drop[Table,Schema]Statement
 	unique_ptr<SQLStatement> TransformDrop(duckdb_libpgquery::PGNode *node);
 	//! Transform a Postgres duckdb_libpgquery::T_PGInsertStmt node into a InsertStatement
 	unique_ptr<InsertStatement> TransformInsert(duckdb_libpgquery::PGNode *node);
+
+	//! Transform a Postgres duckdb_libpgquery::T_PGOnConflictClause node into a OnConflictInfo
+	unique_ptr<OnConflictInfo> TransformOnConflictClause(duckdb_libpgquery::PGOnConflictClause *node,
+	                                                     const string &relname);
+	//! Transform a ON CONFLICT shorthand into a OnConflictInfo
+	unique_ptr<OnConflictInfo> DummyOnConflictClause(duckdb_libpgquery::PGOnConflictActionAlias type,
+	                                                 const string &relname);
 	//! Transform a Postgres duckdb_libpgquery::T_PGCopyStmt node into a CopyStatement
 	unique_ptr<CopyStatement> TransformCopy(duckdb_libpgquery::PGNode *node);
 	void TransformCopyOptions(CopyInfo &info, duckdb_libpgquery::PGList *options);
@@ -219,6 +230,18 @@ private:
 	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell *cell, ColumnDefinition &column,
 	                                           idx_t index);
 
+	//===--------------------------------------------------------------------===//
+	// Update transform
+	//===--------------------------------------------------------------------===//
+	unique_ptr<UpdateSetInfo> TransformUpdateSetInfo(duckdb_libpgquery::PGList *target_list,
+	                                                 duckdb_libpgquery::PGNode *where_clause);
+
+	//===--------------------------------------------------------------------===//
+	// Index transform
+	//===--------------------------------------------------------------------===//
+	vector<unique_ptr<ParsedExpression>> TransformIndexParameters(duckdb_libpgquery::PGList *list,
+	                                                              const string &relation_name);
+
 	//===--------------------------------------------------------------------===//
 	// Collation transform
 	//===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/planner/bind_context.hpp

@@ -9,8 +9,6 @@
 #pragma once
 
 #include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
@@ -28,6 +26,9 @@ class BoundQueryNode;
 
 class StarExpression;
 
+class TableCatalogEntry;
+class TableFunctionCatalogEntry;
+
 struct UsingColumnSet {
 	string primary_binding;
 	unordered_set<string> bindings;
@@ -82,7 +83,7 @@ public:
 
 	//! Adds a base table with the given alias to the BindContext.
 	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
-	                  vector<column_t> &bound_column_ids, StandardEntry *entry);
+	                  vector<column_t> &bound_column_ids, StandardEntry *entry, bool add_row_id = true);
 	//! Adds a call to a table function with the given alias to the BindContext.
 	void AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
 	                      const vector<LogicalType> &types, vector<column_t> &bound_column_ids, StandardEntry *entry);

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -8,19 +8,19 @@
 
 #pragma once
 
+#include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/enums/join_type.hpp"
+#include "duckdb/common/enums/statement_type.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/column_definition.hpp"
+#include "duckdb/parser/query_node.hpp"
+#include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/parser/tokens.hpp"
 #include "duckdb/planner/bind_context.hpp"
+#include "duckdb/planner/bound_statement.hpp"
 #include "duckdb/planner/bound_tokens.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/bound_statement.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/common/enums/statement_type.hpp"
-#include "duckdb/common/enums/join_type.hpp"
 
 namespace duckdb {
 class BoundResultModifier;
@@ -32,6 +32,12 @@ class OrderBinder;
 class TableCatalogEntry;
 class ViewCatalogEntry;
 class TableMacroCatalogEntry;
+class UpdateSetInfo;
+class LogicalProjection;
+
+class ColumnList;
+class ExternalDependency;
+class TableFunction;
 
 struct CreateInfo;
 struct BoundCreateTableInfo;
@@ -48,7 +54,7 @@ struct CorrelatedColumnInfo {
 	idx_t depth;
 
 	CorrelatedColumnInfo(ColumnBinding binding, LogicalType type_p, string name_p, idx_t depth)
-	    : binding(binding), type(move(type_p)), name(move(name_p)), depth(depth) {
+	    : binding(binding), type(std::move(type_p)), name(std::move(name_p)), depth(depth) {
 	}
 	explicit CorrelatedColumnInfo(BoundColumnRefExpression &expr)
 	    : CorrelatedColumnInfo(expr.binding, expr.return_type, expr.GetName(), expr.depth) {
@@ -71,12 +77,13 @@ class Binder : public std::enable_shared_from_this<Binder> {
 	friend class RecursiveSubqueryPlanner;
 
 public:
-	static shared_ptr<Binder> CreateBinder(ClientContext &context, Binder *parent = nullptr, bool inherit_ctes = true);
+	DUCKDB_API static shared_ptr<Binder> CreateBinder(ClientContext &context, Binder *parent = nullptr,
+	                                                  bool inherit_ctes = true);
 
 	//! The client context
 	ClientContext &context;
 	//! A mapping of names to common table expressions
-	case_insensitive_map_t<CommonTableExpressionInfo *> CTE_bindings;
+	case_insensitive_map_t<CommonTableExpressionInfo *> CTE_bindings; // NOLINT
 	//! The CTEs that have already been bound
 	unordered_set<CommonTableExpressionInfo *> bound_ctes;
 	//! The bind context
@@ -96,8 +103,8 @@ public:
 	vector<DummyBinding> *lambda_bindings = nullptr;
 
 public:
-	BoundStatement Bind(SQLStatement &statement);
-	BoundStatement Bind(QueryNode &node);
+	DUCKDB_API BoundStatement Bind(SQLStatement &statement);
+	DUCKDB_API BoundStatement Bind(QueryNode &node);
 
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info);
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema);
@@ -141,21 +148,28 @@ public:
 	string FormatError(TableRef &ref_context, const string &message);
 
 	string FormatErrorRecursive(idx_t query_location, const string &message, vector<ExceptionFormatValue> &values);
-	template <class T, typename... Args>
+	template <class T, typename... ARGS>
 	string FormatErrorRecursive(idx_t query_location, const string &msg, vector<ExceptionFormatValue> &values, T param,
-	                            Args... params) {
+	                            ARGS... params) {
 		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
 		return FormatErrorRecursive(query_location, msg, values, params...);
 	}
 
-	template <typename... Args>
-	string FormatError(idx_t query_location, const string &msg, Args... params) {
+	template <typename... ARGS>
+	string FormatError(idx_t query_location, const string &msg, ARGS... params) {
 		vector<ExceptionFormatValue> values;
 		return FormatErrorRecursive(query_location, msg, values, params...);
 	}
 
+	unique_ptr<LogicalOperator> BindUpdateSet(LogicalOperator *op, unique_ptr<LogicalOperator> root,
+	                                          UpdateSetInfo &set_info, TableCatalogEntry *table,
+	                                          vector<PhysicalIndex> &columns);
+	void BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert *insert, UpdateSetInfo &set_info,
+	                                TableCatalogEntry &table);
+	void BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt);
+
 	static void BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema);
-	static void BindLogicalType(ClientContext &context, LogicalType &type, const string &catalog = INVALID_CATALOG,
+	static void BindLogicalType(ClientContext &context, LogicalType &type, Catalog *catalog = nullptr,
 	                            const string &schema = INVALID_SCHEMA);
 
 	bool HasMatchingBinding(const string &table_name, const string &column_name, string &error_message);
@@ -199,7 +213,7 @@ private:
 	//! Bind the expressions of generated columns to check for errors
 	void BindGeneratedColumns(BoundCreateTableInfo &info);
 	//! Bind the default values of the columns of a table
-	void BindDefaultValues(ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults);
+	void BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults);
 	//! Bind a limit value (LIMIT or OFFSET)
 	unique_ptr<Expression> BindDelimiter(ClientContext &context, OrderBinder &order_binder,
 	                                     unique_ptr<ParsedExpression> delimiter, const LogicalType &type,
@@ -252,7 +266,6 @@ private:
 	unique_ptr<LogicalOperator> CreatePlan(BoundQueryNode &node);
 
 	unique_ptr<BoundTableRef> Bind(BaseTableRef &ref);
-	unique_ptr<BoundTableRef> Bind(CrossProductRef &ref);
 	unique_ptr<BoundTableRef> Bind(JoinRef &ref);
 	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, CommonTableExpressionInfo *cte = nullptr);
 	unique_ptr<BoundTableRef> Bind(TableFunctionRef &ref);
@@ -273,7 +286,6 @@ private:
 	                          unique_ptr<ExternalDependency> external_dependency);
 
 	unique_ptr<LogicalOperator> CreatePlan(BoundBaseTableRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundCrossProductRef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundJoinRef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundSubqueryRef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundTableFunction &ref);
@@ -327,7 +339,7 @@ private:
 public:
 	// This should really be a private constructor, but make_shared does not allow it...
 	// If you are thinking about calling this, you should probably call Binder::CreateBinder
-	Binder(bool I_know_what_I_am_doing, ClientContext &context, shared_ptr<Binder> parent, bool inherit_ctes);
+	Binder(bool i_know_what_i_am_doing, ClientContext &context, shared_ptr<Binder> parent, bool inherit_ctes);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/bound_tokens.hpp

@@ -46,7 +46,6 @@ class BoundWindowExpression;
 class BoundTableRef;
 
 class BoundBaseTableRef;
-class BoundCrossProductRef;
 class BoundJoinRef;
 class BoundSubqueryRef;
 class BoundTableFunction;

package/src/duckdb/src/include/duckdb/planner/column_binding.hpp

@@ -15,6 +15,7 @@ namespace duckdb {
 
 struct ColumnBinding {
 	idx_t table_index;
+	// This index is local to a Binding, and has no meaning outside of the context of the Binding that created it
 	idx_t column_index;
 
 	ColumnBinding() : table_index(DConstants::INVALID_INDEX), column_index(DConstants::INVALID_INDEX) {

package/src/duckdb/src/include/duckdb/planner/constraints/bound_foreign_key_constraint.hpp

@@ -18,8 +18,8 @@ class BoundForeignKeyConstraint : public BoundConstraint {
 public:
 	BoundForeignKeyConstraint(ForeignKeyInfo info_p, physical_index_set_t pk_key_set_p,
 	                          physical_index_set_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)) {
+	    : BoundConstraint(ConstraintType::FOREIGN_KEY), info(std::move(info_p)), pk_key_set(std::move(pk_key_set_p)),
+	      fk_key_set(std::move(fk_key_set_p)) {
 #ifdef DEBUG
 		D_ASSERT(info.pk_keys.size() == pk_key_set.size());
 		for (auto &key : info.pk_keys) {

package/src/duckdb/src/include/duckdb/planner/constraints/bound_unique_constraint.hpp

@@ -17,7 +17,7 @@ namespace duckdb {
 class BoundUniqueConstraint : public BoundConstraint {
 public:
 	BoundUniqueConstraint(vector<LogicalIndex> keys, logical_index_set_t key_set, bool is_primary_key)
-	    : BoundConstraint(ConstraintType::UNIQUE), keys(move(keys)), key_set(move(key_set)),
+	    : BoundConstraint(ConstraintType::UNIQUE), keys(std::move(keys)), key_set(std::move(key_set)),
 	      is_primary_key(is_primary_key) {
 #ifdef DEBUG
 		D_ASSERT(keys.size() == key_set.size());

package/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp

@@ -35,8 +35,8 @@ public:
 	static unique_ptr<Expression> AddDefaultCastToType(unique_ptr<Expression> expr, const LogicalType &target_type,
 	                                                   bool try_cast = false);
 	//! Cast an expression to the specified SQL type if required
-	static unique_ptr<Expression> AddCastToType(ClientContext &context, unique_ptr<Expression> expr,
-	                                            const LogicalType &target_type, bool try_cast = false);
+	DUCKDB_API static unique_ptr<Expression> AddCastToType(ClientContext &context, unique_ptr<Expression> expr,
+	                                                       const LogicalType &target_type, bool try_cast = false);
 	//! Returns true if a cast is invertible (i.e. CAST(s -> t -> s) = s for all values of s). This is not true for e.g.
 	//! boolean casts, because that can be e.g. -1 -> TRUE -> 1. This is necessary to prevent some optimizer bugs.
 	static bool CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type);