duckdb 0.3.2-dev29.0 → 0.3.2-dev50.0

package/src/duckdb.cpp

@@ -679,6 +679,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 //! Represents a reference to a column from either the FROM clause or from an
@@ -689,13 +690,16 @@ public:
 	ColumnRefExpression(string column_name, string table_name);
 	//! Only specify the column name, the table name will be derived later
 	explicit ColumnRefExpression(string column_name);
+	//! Specify a set of names
+	explicit ColumnRefExpression(vector<string> column_names);
 
-	//! Column name that is referenced
-	string column_name;
-	//! Table name of the column name that is referenced (optional)
-	string table_name;
+	//! The stack of names in order of which they appear (column_names[0].column_names[1].column_names[2]....)
+	vector<string> column_names;
 
 public:
+	bool IsQualified() const;
+	const string &GetColumnName() const;
+	const string &GetTableName() const;
 	bool IsScalar() const override {
 		return false;
 	}
@@ -972,6 +976,8 @@ struct BoundColumnReferenceInfo {
 };
 
 struct BindResult {
+	BindResult() {
+	}
 	explicit BindResult(string error) : error(error) {
 	}
 	explicit BindResult(unique_ptr<Expression> expr) : expression(move(expr)) {
@@ -1008,9 +1014,16 @@ public:
 
 	string Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false);
 
+	unique_ptr<ParsedExpression> CreateStructExtract(unique_ptr<ParsedExpression> base, string field_name);
+	BindResult BindQualifiedColumnName(ColumnRefExpression &colref, const string &table_name);
+
+	unique_ptr<ParsedExpression> QualifyColumnName(const string &column_name, string &error_message);
+	unique_ptr<ParsedExpression> QualifyColumnName(ColumnRefExpression &colref, string &error_message);
+
 	// Bind table names to ColumnRefExpressions
-	static void BindTableNames(Binder &binder, ParsedExpression &expr,
-	                           unordered_map<string, idx_t> *alias_map = nullptr);
+	void QualifyColumnNames(unique_ptr<ParsedExpression> &expr);
+	static void QualifyColumnNames(Binder &binder, unique_ptr<ParsedExpression> &expr);
+
 	static unique_ptr<Expression> PushCollation(ClientContext &context, unique_ptr<Expression> source,
 	                                            const string &collation, bool equality_only = false);
 	static void TestCollation(ClientContext &context, const string &collation);
@@ -1058,9 +1071,7 @@ protected:
 	virtual BindResult BindMacro(FunctionExpression &expr, MacroCatalogEntry *macro, idx_t depth,
 	                             unique_ptr<ParsedExpression> *expr_ptr);
 
-	virtual void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
-	virtual void ReplaceMacroParametersRecursive(ParsedExpression &expr, QueryNode &node);
-	virtual void ReplaceMacroParametersRecursive(ParsedExpression &expr, TableRef &ref);
+	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
 
 	virtual string UnsupportedAggregateMessage();
 	virtual string UnsupportedUnnestMessage();
@@ -1117,8 +1128,11 @@ struct Binding {
 
 public:
 	bool TryGetBindingIndex(const string &column_name, column_t &column_index);
+	column_t GetBindingIndex(const string &column_name);
 	bool HasMatchingBinding(const string &column_name);
+	virtual string ColumnNotFoundError(const string &column_name) const;
 	virtual BindResult Bind(ColumnRefExpression &colref, idx_t depth);
+	virtual TableCatalogEntry *GetTableEntry();
 };
 
 //! TableBinding is exactly like the Binding, except it keeps track of which columns were bound in the linked LogicalGet
@@ -1132,11 +1146,16 @@ struct TableBinding : public Binding {
 
 public:
 	BindResult Bind(ColumnRefExpression &colref, idx_t depth) override;
+	TableCatalogEntry *GetTableEntry() override;
+	string ColumnNotFoundError(const string &column_name) const override;
 };
 
 //! MacroBinding is like the Binding, except the alias and index are set by default. Used for binding Macro
 //! Params/Arguments.
 struct MacroBinding : public Binding {
+	static constexpr const char *MACRO_NAME = "0_macro_parameters";
+
+public:
 	MacroBinding(vector<LogicalType> types_p, vector<string> names_p, string macro_name);
 
 	//! Arguments
@@ -1191,6 +1210,10 @@ public:
 	string BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name);
 	BindResult BindColumn(PositionalReferenceExpression &ref, idx_t depth);
 
+	unique_ptr<ParsedExpression> CreateColumnReference(const string &table_name, const string &column_name);
+	unique_ptr<ParsedExpression> CreateColumnReference(const string &schema_name, const string &table_name,
+	                                                   const string &column_name);
+
 	//! Generate column expressions for all columns that are present in the
 	//! referenced tables. This is used to resolve the * expression in a
 	//! selection list.
@@ -1259,12 +1282,13 @@ public:
 	//! Add all the bindings from a BindContext to this BindContext. The other BindContext is destroyed in the process.
 	void AddContext(BindContext other);
 
-private:
-	void AddBinding(const string &alias, unique_ptr<Binding> binding);
 	//! Gets a binding of the specified name. Returns a nullptr and sets the out_error if the binding could not be
 	//! found.
 	Binding *GetBinding(const string &name, string &out_error);
 
+private:
+	void AddBinding(const string &alias, unique_ptr<Binding> binding);
+
 private:
 	//! The set of bindings
 	case_insensitive_map_t<unique_ptr<Binding>> bindings;
@@ -1456,6 +1480,10 @@ public:
 
 	static void BindLogicalType(ClientContext &context, LogicalType &type, const string &schema = "");
 
+	bool HasMatchingBinding(const string &table_name, const string &column_name, string &error_message);
+	bool HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
+	                        string &error_message);
+
 private:
 	//! The parent binder (if any)
 	shared_ptr<Binder> parent;
@@ -7765,6 +7793,7 @@ private:
 
 
 
+
 #include <functional>
 
 namespace duckdb {
@@ -7776,6 +7805,11 @@ public:
 	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);
 };
 
 } // namespace duckdb
@@ -7962,8 +7996,8 @@ unique_ptr<CatalogEntry> TableCatalogEntry::AlterEntry(ClientContext &context, A
 static void RenameExpression(ParsedExpression &expr, RenameColumnInfo &info) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
 		auto &colref = (ColumnRefExpression &)expr;
-		if (colref.column_name == info.old_name) {
-			colref.column_name = info.new_name;
+		if (colref.column_names[0] == info.old_name) {
+			colref.column_names[0] = info.new_name;
 		}
 	}
 	ParsedExpressionIterator::EnumerateChildren(
@@ -49700,6 +49734,7 @@ void ExpressionExecutor::ExecuteExpression(idx_t expr_idx, Vector &result) {
 
 Value ExpressionExecutor::EvaluateScalar(const Expression &expr) {
 	D_ASSERT(expr.IsFoldable());
+	D_ASSERT(expr.IsScalar());
 	// use an ExpressionExecutor to execute the expression
 	ExpressionExecutor executor(expr);
 
@@ -58827,6 +58862,7 @@ struct TableScanBindData : public FunctionData {
 //! The table scan function represents a sequential scan over one of DuckDB's base tables.
 struct TableScanFunction {
 	static TableFunction GetFunction();
+	static TableCatalogEntry *GetTableEntry(const TableFunction &function, const FunctionData *bind_data);
 };
 
 } // namespace duckdb
@@ -68477,6 +68513,8 @@ public:
 
 	string GetName() const override;
 	string ParamsToString() const override;
+	//! Returns the underlying table that is being scanned, or nullptr if there is none
+	TableCatalogEntry *GetTable() const;
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;
@@ -79011,7 +79049,7 @@ string MacroFunction::ValidateArguments(MacroCatalogEntry &macro_func, FunctionE
 		error = StringUtil::Format(
 		    "Macro function '%s(%s)' requires ", macro_func.name,
 		    StringUtil::Join(parameters, parameters.size(), ", ", [](const unique_ptr<ParsedExpression> &p) {
-			    return ((ColumnRefExpression &)*p).column_name;
+			    return ((ColumnRefExpression &)*p).column_names[0];
 		    }));
 		error += parameters.size() == 1 ? "a single positional argument"
 		                                : StringUtil::Format("%i positional arguments", parameters.size());
@@ -98709,6 +98747,14 @@ TableFunction TableScanFunction::GetFunction() {
 	return scan_function;
 }
 
+TableCatalogEntry *TableScanFunction::GetTableEntry(const TableFunction &function, const FunctionData *bind_data_p) {
+	if (function.function != TableScanFunc || !bind_data_p) {
+		return nullptr;
+	}
+	auto &bind_data = (TableScanBindData &)*bind_data_p;
+	return bind_data.table;
+}
+
 } // namespace duckdb
 
 
@@ -106482,10 +106528,10 @@ shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const str
 				throw ParserException("Expected a single expression as join condition");
 			}
 			auto &colref = (ColumnRefExpression &)*expr;
-			if (!colref.table_name.empty()) {
-				throw ParserException("Expected empty table name for column in USING clause");
+			if (colref.IsQualified()) {
+				throw ParserException("Expected unqualified column for column in USING clause");
 			}
-			using_columns.push_back(colref.column_name);
+			using_columns.push_back(colref.column_names[0]);
 		}
 		return make_shared<JoinRelation>(shared_from_this(), other, move(using_columns), type);
 	} else {
@@ -115103,6 +115149,10 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalProj
                                                                      unique_ptr<LogicalOperator> *node_ptr) {
 	// first propagate to the child
 	node_stats = PropagateStatistics(proj.children[0]);
+	if (proj.children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
+		ReplaceWithEmptyResult(*node_ptr);
+		return move(node_stats);
+	}
 
 	// then propagate to each of the expressions
 	for (idx_t i = 0; i < proj.expressions.size(); i++) {
@@ -121779,53 +121829,85 @@ unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type,
 
 namespace duckdb {
 
-//! Specify both the column and table name
 ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
-    : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF), column_name(move(column_name)),
-      table_name(move(table_name)) {
+    : ColumnRefExpression(table_name.empty() ? vector<string> {move(column_name)}
+                                             : vector<string> {move(table_name), move(column_name)}) {
+}
+
+ColumnRefExpression::ColumnRefExpression(string column_name) : ColumnRefExpression(vector<string> {move(column_name)}) {
 }
 
-ColumnRefExpression::ColumnRefExpression(string column_name) : ColumnRefExpression(move(column_name), string()) {
+ColumnRefExpression::ColumnRefExpression(vector<string> column_names_p)
+    : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF), column_names(move(column_names_p)) {
+#ifdef DEBUG
+	for (auto &col_name : column_names) {
+		D_ASSERT(!col_name.empty());
+	}
+#endif
+}
+
+bool ColumnRefExpression::IsQualified() const {
+	return column_names.size() > 1;
+}
+
+const string &ColumnRefExpression::GetColumnName() const {
+	D_ASSERT(column_names.size() <= 3);
+	return column_names.back();
+}
+
+const string &ColumnRefExpression::GetTableName() const {
+	D_ASSERT(column_names.size() >= 2 && column_names.size() <= 3);
+	return column_names.size() == 3 ? column_names[1] : column_names[0];
 }
 
 string ColumnRefExpression::GetName() const {
-	return !alias.empty() ? alias : column_name;
+	return !alias.empty() ? alias : column_names.back();
 }
 
 string ColumnRefExpression::ToString() const {
-	if (table_name.empty()) {
-		return column_name;
-	} else {
-		return table_name + "." + column_name;
+	string result;
+	for (idx_t i = 0; i < column_names.size(); i++) {
+		if (i > 0) {
+			result += ".";
+		}
+		result += column_names[i];
 	}
+	return result;
 }
 
 bool ColumnRefExpression::Equals(const ColumnRefExpression *a, const ColumnRefExpression *b) {
-	return a->column_name == b->column_name && a->table_name == b->table_name;
+	return a->column_names == b->column_names;
 }
 
 hash_t ColumnRefExpression::Hash() const {
 	hash_t result = ParsedExpression::Hash();
-	result = CombineHash(result, duckdb::Hash<const char *>(column_name.c_str()));
+	for (auto &column_name : column_names) {
+		result = CombineHash(result, duckdb::Hash<const char *>(column_name.c_str()));
+	}
 	return result;
 }
 
 unique_ptr<ParsedExpression> ColumnRefExpression::Copy() const {
-	auto copy = make_unique<ColumnRefExpression>(column_name, table_name);
+	auto copy = make_unique<ColumnRefExpression>(column_names);
 	copy->CopyProperties(*this);
 	return move(copy);
 }
 
 void ColumnRefExpression::Serialize(Serializer &serializer) {
 	ParsedExpression::Serialize(serializer);
-	serializer.WriteString(table_name);
-	serializer.WriteString(column_name);
+	serializer.Write<idx_t>(column_names.size());
+	for (auto &column_name : column_names) {
+		serializer.WriteString(column_name);
+	}
 }
 
 unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto table_name = source.Read<string>();
-	auto column_name = source.Read<string>();
-	auto expression = make_unique<ColumnRefExpression>(column_name, table_name);
+	auto column_count = source.Read<idx_t>();
+	vector<string> column_names;
+	for (idx_t i = 0; i < column_count; i++) {
+		column_names.push_back(source.Read<string>());
+	}
+	auto expression = make_unique<ColumnRefExpression>(move(column_names));
 	return move(expression);
 }
 
@@ -123571,6 +123653,129 @@ unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &source)
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/query_node/recursive_cte_node.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+class RecursiveCTENode : public QueryNode {
+public:
+	RecursiveCTENode() : QueryNode(QueryNodeType::RECURSIVE_CTE_NODE) {
+	}
+
+	string ctename;
+	bool union_all;
+	//! The left side of the set operation
+	unique_ptr<QueryNode> left;
+	//! The right side of the set operation
+	unique_ptr<QueryNode> right;
+	//! Aliases of the recursive CTE node
+	vector<string> aliases;
+
+	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
+		return left->GetSelectList();
+	}
+
+public:
+	bool Equals(const QueryNode *other) const override;
+	//! Create a copy of this SelectNode
+	unique_ptr<QueryNode> Copy() override;
+
+	//! Serializes a SelectNode to a stand-alone binary blob
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a SelectNode
+	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
+};
+
+} // namespace duckdb
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/crossproductref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! Represents a cross product
+class CrossProductRef : public TableRef {
+public:
+	CrossProductRef() : TableRef(TableReferenceType::CROSS_PRODUCT) {
+	}
+
+	//! The left hand side of the cross product
+	unique_ptr<TableRef> left;
+	//! The right hand side of the cross product
+	unique_ptr<TableRef> right;
+
+public:
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a CrossProductRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a CrossProductRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/emptytableref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! Represents a cross product
+class EmptyTableRef : public TableRef {
+public:
+	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
+	}
+
+public:
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a DummyTableRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a DummyTableRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+
+
+
+
+
+
 namespace duckdb {
 
 void ParsedExpressionIterator::EnumerateChildren(const ParsedExpression &expression,
@@ -123706,6 +123911,91 @@ void ParsedExpressionIterator::EnumerateChildren(
 	}
 }
 
+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++) {
+			for (idx_t j = 0; j < el_ref.values[i].size(); j++) {
+				callback(el_ref.values[i][j]);
+			}
+		}
+		break;
+	}
+	case TableReferenceType::JOIN: {
+		auto &j_ref = (JoinRef &)ref;
+		EnumerateTableRefChildren(*j_ref.left, callback);
+		EnumerateTableRefChildren(*j_ref.right, callback);
+		callback(j_ref.condition);
+		break;
+	}
+	case TableReferenceType::SUBQUERY: {
+		auto &sq_ref = (SubqueryRef &)ref;
+		EnumerateQueryNodeChildren(*sq_ref.subquery->node, callback);
+		break;
+	}
+	case TableReferenceType::TABLE_FUNCTION: {
+		auto &tf_ref = (TableFunctionRef &)ref;
+		callback(tf_ref.function);
+		break;
+	}
+	case TableReferenceType::BASE_TABLE:
+	case TableReferenceType::EMPTY:
+		// these TableRefs do not need to be unfolded
+		break;
+	default:
+		throw NotImplementedException("TableRef type not implemented for traversal");
+	}
+}
+
+void ParsedExpressionIterator::EnumerateQueryNodeChildren(
+    QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
+	switch (node.type) {
+	case QueryNodeType::RECURSIVE_CTE_NODE: {
+		auto &rcte_node = (RecursiveCTENode &)node;
+		EnumerateQueryNodeChildren(*rcte_node.left, callback);
+		EnumerateQueryNodeChildren(*rcte_node.right, callback);
+		break;
+	}
+	case QueryNodeType::SELECT_NODE: {
+		auto &sel_node = (SelectNode &)node;
+		for (idx_t i = 0; i < sel_node.select_list.size(); i++) {
+			callback(sel_node.select_list[i]);
+		}
+		for (idx_t i = 0; i < sel_node.groups.group_expressions.size(); i++) {
+			callback(sel_node.groups.group_expressions[i]);
+		}
+		if (sel_node.where_clause) {
+			callback(sel_node.where_clause);
+		}
+		if (sel_node.having) {
+			callback(sel_node.having);
+		}
+
+		EnumerateTableRefChildren(*sel_node.from_table.get(), callback);
+		break;
+	}
+	case QueryNodeType::SET_OPERATION_NODE: {
+		auto &setop_node = (SetOperationNode &)node;
+		EnumerateQueryNodeChildren(*setop_node.left, callback);
+		EnumerateQueryNodeChildren(*setop_node.right, callback);
+		break;
+	}
+	default:
+		throw NotImplementedException("QueryNode type not implemented for traversal");
+	}
+	for (auto &kv : node.cte_map) {
+		EnumerateQueryNodeChildren(*kv.second->query->node, callback);
+	}
+}
+
 } // namespace duckdb
 
 
@@ -129352,52 +129642,6 @@ string QueryErrorContext::FormatErrorRecursive(const string &msg, vector<Excepti
 	return Format(statement->query, error_message, query_location);
 }
 
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node/recursive_cte_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class RecursiveCTENode : public QueryNode {
-public:
-	RecursiveCTENode() : QueryNode(QueryNodeType::RECURSIVE_CTE_NODE) {
-	}
-
-	string ctename;
-	bool union_all;
-	//! The left side of the set operation
-	unique_ptr<QueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<QueryNode> right;
-	//! Aliases of the recursive CTE node
-	vector<string> aliases;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		return left->GetSelectList();
-	}
-
-public:
-	bool Equals(const QueryNode *other) const override;
-	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() override;
-
-	//! Serializes a SelectNode to a stand-alone binary blob
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a SelectNode
-	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
-};
-
 } // namespace duckdb
 
 
@@ -130486,41 +130730,6 @@ unique_ptr<TableRef> BaseTableRef::Copy() {
 	return move(copy);
 }
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/crossproductref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-//! Represents a cross product
-class CrossProductRef : public TableRef {
-public:
-	CrossProductRef() : TableRef(TableReferenceType::CROSS_PRODUCT) {
-	}
-
-	//! The left hand side of the cross product
-	unique_ptr<TableRef> left;
-	//! The right hand side of the cross product
-	unique_ptr<TableRef> right;
-
-public:
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a CrossProductRef
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a CrossProductRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
 
 
 
@@ -130564,36 +130773,6 @@ unique_ptr<TableRef> CrossProductRef::Deserialize(Deserializer &source) {
 }
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/emptytableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-//! Represents a cross product
-class EmptyTableRef : public TableRef {
-public:
-	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
-	}
-
-public:
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a DummyTableRef
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a DummyTableRef
-	static unique_ptr<TableRef> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
 
 
 
@@ -130863,13 +131042,6 @@ unique_ptr<TableRef> TableFunctionRef::Copy() {
 
 
 
-
-
-
-
-
-
-
 namespace duckdb {
 
 string TableRef::ToString() const {
@@ -131250,28 +131422,13 @@ unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::
 		if (fields->length < 1) {
 			throw InternalException("Unexpected field length");
 		}
-		string column_name, table_name;
-		if (fields->length == 1) {
-			column_name = string(reinterpret_cast<duckdb_libpgquery::PGValue *>(fields->head->data.ptr_value)->val.str);
-			auto colref = make_unique<ColumnRefExpression>(column_name, table_name);
-			colref->query_location = root->location;
-			return move(colref);
-		} else if (fields->length == 2) {
-			table_name = string(reinterpret_cast<duckdb_libpgquery::PGValue *>(fields->head->data.ptr_value)->val.str);
-			auto col_node = reinterpret_cast<duckdb_libpgquery::PGNode *>(fields->head->next->data.ptr_value);
-			switch (col_node->type) {
-			case duckdb_libpgquery::T_PGString: {
-				column_name = string(reinterpret_cast<duckdb_libpgquery::PGValue *>(col_node)->val.str);
-				auto colref = make_unique<ColumnRefExpression>(column_name, table_name);
-				colref->query_location = root->location;
-				return move(colref);
-			}
-			default:
-				throw NotImplementedException("ColumnRef not implemented!");
-			}
-		} else {
-			throw NotImplementedException("ColumnRef not implemented!");
+		vector<string> column_names;
+		for (auto node = fields->head; node; node = node->next) {
+			column_names.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
 		}
+		auto colref = make_unique<ColumnRefExpression>(move(column_names));
+		colref->query_location = root->location;
+		return move(colref);
 	}
 	case duckdb_libpgquery::T_PGAStar: {
 		return TransformStarExpression(head_node);
@@ -131942,10 +132099,10 @@ static string ExtractColumnFromLambda(ParsedExpression &expr) {
 		throw ParserException("Lambda parameter must be a column name");
 	}
 	auto &colref = (ColumnRefExpression &)expr;
-	if (!colref.table_name.empty()) {
+	if (colref.IsQualified()) {
 		throw ParserException("Lambda parameter must be an unqualified name (e.g. 'x', not 'a.x')");
 	}
-	return colref.column_name;
+	return colref.column_names[0];
 }
 
 unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGLambdaFunction *node) {
@@ -135600,6 +135757,34 @@ unordered_set<string> BindContext::GetMatchingBindings(const string &column_name
 	return result;
 }
 
+unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &table_name, const string &column_name) {
+	string schema_name;
+	return CreateColumnReference(schema_name, table_name, column_name);
+}
+
+unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &schema_name, const string &table_name,
+                                                                const string &column_name) {
+	string error_message;
+	vector<string> names;
+	if (!schema_name.empty()) {
+		names.push_back(schema_name);
+	}
+	names.push_back(table_name);
+	names.push_back(column_name);
+
+	auto result = make_unique<ColumnRefExpression>(move(names));
+	// because of case insensitivity in the binder we rename the column to the original name
+	// as it appears in the binding itself
+	auto binding = GetBinding(table_name, error_message);
+	if (binding) {
+		auto column_index = binding->GetBindingIndex(column_name);
+		if (column_index < binding->names.size() && binding->names[column_index] != column_name) {
+			result->alias = binding->names[column_index];
+		}
+	}
+	return move(result);
+}
+
 Binding *BindContext::GetCTEBinding(const string &ctename) {
 	auto match = cte_bindings.find(ctename);
 	if (match == cte_bindings.end()) {
@@ -135625,12 +135810,12 @@ Binding *BindContext::GetBinding(const string &name, string &out_error) {
 }
 
 BindResult BindContext::BindColumn(ColumnRefExpression &colref, idx_t depth) {
-	if (colref.table_name.empty()) {
-		return BindResult(StringUtil::Format("Could not bind alias \"%s\"!", colref.column_name));
+	if (!colref.IsQualified()) {
+		throw InternalException("Could not bind alias \"%s\"!", colref.GetColumnName());
 	}
 
 	string error;
-	auto binding = GetBinding(colref.table_name, error);
+	auto binding = GetBinding(colref.GetTableName(), error);
 	if (!binding) {
 		return BindResult(error);
 	}
@@ -136422,57 +136607,237 @@ BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth
 
 
 
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/where_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
 namespace duckdb {
 
-BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref, idx_t depth) {
-	D_ASSERT(!colref.column_name.empty());
-	// individual column reference
-	// resolve to either a base table or a subquery expression
-	if (colref.table_name.empty()) {
-		auto using_binding = binder.bind_context.GetUsingBinding(colref.column_name);
-		if (using_binding) {
-			// we are referencing a USING column
-			// check if we can refer to one of the base columns directly
-			unique_ptr<Expression> expression;
-			if (!using_binding->primary_binding.empty()) {
-				// we can! just assign the table name and re-bind
-				colref.table_name = using_binding->primary_binding;
-				return BindExpression(colref, depth);
-			} else {
-				// we cannot! we need to bind this as a coalesce between all the relevant columns
-				auto coalesce = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-				for (auto &entry : using_binding->bindings) {
-					coalesce->children.push_back(make_unique<ColumnRefExpression>(colref.column_name, entry));
-				}
-				return BindExpression(*coalesce, depth);
+class ColumnAliasBinder;
+
+//! The WHERE binder is responsible for binding an expression within the WHERE clause of a SQL statement
+class WhereBinder : public ExpressionBinder {
+public:
+	WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder = nullptr);
+
+protected:
+	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	                          bool root_expression = false) override;
+
+	string UnsupportedAggregateMessage() override;
+
+private:
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+
+	ColumnAliasBinder *column_alias_binder;
+};
+
+} // namespace duckdb
+
+
+
+
+
+
+namespace duckdb {
+
+unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &column_name, string &error_message) {
+	auto using_binding = binder.bind_context.GetUsingBinding(column_name);
+	if (using_binding) {
+		// we are referencing a USING column
+		// check if we can refer to one of the base columns directly
+		unique_ptr<Expression> expression;
+		if (!using_binding->primary_binding.empty()) {
+			// we can! just assign the table name and re-bind
+			return make_unique<ColumnRefExpression>(column_name, using_binding->primary_binding);
+		} else {
+			// // we cannot! we need to bind this as a coalesce between all the relevant columns
+			auto coalesce = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
+			for (auto &entry : using_binding->bindings) {
+				coalesce->children.push_back(make_unique<ColumnRefExpression>(column_name, entry));
 			}
+			return move(coalesce);
 		}
-		// no table name: find a binding that contains this
-		if (binder.macro_binding != nullptr && binder.macro_binding->HasMatchingBinding(colref.column_name)) {
-			// priority to macro parameter bindings TODO: throw a warning when this name conflicts
-			colref.table_name = binder.macro_binding->alias;
+	}
+	// no table name: find a binding that contains this
+	if (binder.macro_binding != nullptr && binder.macro_binding->HasMatchingBinding(column_name)) {
+		// priority to macro parameter bindings TODO: throw a warning when this name conflicts
+		D_ASSERT(!binder.macro_binding->alias.empty());
+		return make_unique<ColumnRefExpression>(column_name, binder.macro_binding->alias);
+	} else {
+		string table_name = binder.bind_context.GetMatchingBinding(column_name);
+		if (table_name.empty()) {
+			auto similar_bindings = binder.bind_context.GetSimilarBindings(column_name);
+			string candidate_str = StringUtil::CandidatesMessage(similar_bindings, "Candidate bindings");
+			error_message =
+			    StringUtil::Format("Referenced column \"%s\" not found in FROM clause!%s", column_name, candidate_str);
+			return nullptr;
+		}
+		return binder.bind_context.CreateColumnReference(table_name, column_name);
+	}
+}
+
+void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr) {
+	switch (expr->type) {
+	case ExpressionType::COLUMN_REF: {
+		auto &colref = (ColumnRefExpression &)*expr;
+		string error_message;
+		auto new_expr = QualifyColumnName(colref, error_message);
+		if (new_expr) {
+			if (!expr->alias.empty()) {
+				new_expr->alias = expr->alias;
+			}
+			expr = move(new_expr);
+		}
+		break;
+	}
+	case ExpressionType::POSITIONAL_REFERENCE: {
+		auto &ref = (PositionalReferenceExpression &)*expr;
+		if (ref.alias.empty()) {
+			string table_name, column_name;
+			auto error = binder.bind_context.BindColumn(ref, table_name, column_name);
+			if (error.empty()) {
+				ref.alias = column_name;
+			}
+		}
+		break;
+	}
+	default:
+		break;
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyColumnNames(child); });
+}
+
+void ExpressionBinder::QualifyColumnNames(Binder &binder, unique_ptr<ParsedExpression> &expr) {
+	WhereBinder where_binder(binder, binder.context);
+	where_binder.QualifyColumnNames(expr);
+}
+
+unique_ptr<ParsedExpression> ExpressionBinder::CreateStructExtract(unique_ptr<ParsedExpression> base,
+                                                                   string field_name) {
+	vector<unique_ptr<ParsedExpression>> children;
+	children.push_back(move(base));
+	children.push_back(make_unique_base<ParsedExpression, ConstantExpression>(Value(move(field_name))));
+	auto extract_fun = make_unique<FunctionExpression>("struct_extract", move(children));
+	return move(extract_fun);
+}
+
+unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpression &colref, string &error_message) {
+	idx_t column_parts = colref.column_names.size();
+	// column names can have an arbitrary amount of dots
+	// here is how the resolution works:
+	if (column_parts == 1) {
+		// no dots (i.e. "part1")
+		// -> part1 refers to a column
+		// check if we can qualify the column name with the table name
+		return QualifyColumnName(colref.GetColumnName(), error_message);
+	} else if (column_parts == 2) {
+		// one dot (i.e. "part1.part2")
+		// EITHER:
+		// -> part1 is a table, part2 is a column
+		// -> part1 is a column, part2 is a property of that column (i.e. struct_extract)
+
+		// first check if part1 is a table
+		if (binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], error_message)) {
+			// it is! return the colref directly
+			return binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1]);
 		} else {
-			colref.table_name = binder.bind_context.GetMatchingBinding(colref.column_name);
+			// otherwise check if we can turn this into a struct extract
+			auto new_colref = make_unique<ColumnRefExpression>(colref.column_names[0]);
+			string other_error;
+			auto qualified_colref = QualifyColumnName(colref.column_names[0], other_error);
+			if (!qualified_colref) {
+				// we could not! bail
+				return nullptr;
+			}
+			// we could: create a struct extract
+			return CreateStructExtract(move(qualified_colref), colref.column_names[1]);
 		}
-		if (colref.table_name.empty()) {
-			auto similar_bindings = binder.bind_context.GetSimilarBindings(colref.column_name);
-			string candidate_str = StringUtil::CandidatesMessage(similar_bindings, "Candidate bindings");
-			return BindResult(binder.FormatError(colref.query_location,
-			                                     "Referenced column \"%s\" not found in FROM clause!%s",
-			                                     colref.column_name.c_str(), candidate_str));
+	} else {
+		// two or more dots (i.e. "part1.part2.part3.part4...")
+		// -> part1 is a schema, part2 is a table, part3 is a column name, part4 and beyond are struct fields
+		// -> part1 is a table, part2 is a column name, part3 and beyond are struct fields
+		// -> part1 is a column, part2 and beyond are struct fields
+
+		// we always prefer the most top-level view
+		// i.e. in case of multiple resolution options, we resolve in order:
+		// -> 1. resolve "part1" as a schema
+		// -> 2. resolve "part1" as a table
+		// -> 3. resolve "part1" as a column
+
+		unique_ptr<ParsedExpression> result_expr;
+		idx_t struct_extract_start;
+		// first check if part1 is a schema
+		if (binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], colref.column_names[2],
+		                              error_message)) {
+			// it is! the column reference is "schema.table.column"
+			// any additional fields are turned into struct_extract calls
+			result_expr = binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1],
+			                                                        colref.column_names[2]);
+			struct_extract_start = 3;
+		} else if (binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], error_message)) {
+			// part1 is a table
+			// the column reference is "table.column"
+			// any additional fields are turned into struct_extract calls
+			result_expr = binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1]);
+			struct_extract_start = 2;
+		} else {
+			// part1 could be a column
+			string col_error;
+			result_expr = QualifyColumnName(colref.column_names[0], col_error);
+			if (!result_expr) {
+				// it is not! return the error
+				return nullptr;
+			}
+			// it is! add the struct extract calls
+			struct_extract_start = 1;
+		}
+		for (idx_t i = struct_extract_start; i < colref.column_names.size(); i++) {
+			result_expr = CreateStructExtract(move(result_expr), colref.column_names[i]);
 		}
+		return result_expr;
+	}
+}
+
+BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t depth) {
+	string error_message;
+	auto expr = QualifyColumnName(colref_p, error_message);
+	if (!expr) {
+		return BindResult(binder.FormatError(colref_p, error_message));
+	}
+	if (expr->type != ExpressionType::COLUMN_REF) {
+		return BindExpression(&expr, depth);
 	}
+	auto &colref = (ColumnRefExpression &)*expr;
+	D_ASSERT(colref.column_names.size() == 2 || colref.column_names.size() == 3);
+	auto &table_name = colref.column_names.size() == 3 ? colref.column_names[1] : colref.column_names[0];
+	// individual column reference
+	// resolve to either a base table or a subquery expression
 	// if it was a macro parameter, let macro_binding bind it to the argument
-	BindResult result = binder.macro_binding != nullptr && colref.table_name == binder.macro_binding->alias
-	                        ? binder.macro_binding->Bind(colref, depth)
-	                        : binder.bind_context.BindColumn(colref, depth);
+	BindResult result;
+	if (binder.macro_binding && table_name == binder.macro_binding->alias) {
+		result = binder.macro_binding->Bind(colref, depth);
+	} else {
+		result = binder.bind_context.BindColumn(colref, depth);
+	}
 	if (!result.HasError()) {
 		BoundColumnReferenceInfo ref;
-		ref.name = colref.column_name;
+		ref.name = colref.column_names.back();
 		ref.query_location = colref.query_location;
 		bound_columns.push_back(move(ref));
 	} else {
-		result.error = binder.FormatError(colref, result.error);
+		result.error = binder.FormatError(colref_p, result.error);
 	}
 	return result;
 }
@@ -136770,11 +137135,6 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth)
 
 
 
-
-
-
-
-
 namespace duckdb {
 
 void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr) {
@@ -136782,7 +137142,14 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	case ExpressionClass::COLUMN_REF: {
 		// if expr is a parameter, replace it with its argument
 		auto &colref = (ColumnRefExpression &)*expr;
-		if (colref.table_name.empty() && macro_binding->HasMatchingBinding(colref.column_name)) {
+		bool bind_macro_parameter = false;
+		if (colref.IsQualified()) {
+			bind_macro_parameter = colref.GetTableName() == MacroBinding::MACRO_NAME;
+		} else {
+			bind_macro_parameter = macro_binding->HasMatchingBinding(colref.GetColumnName());
+		}
+		if (bind_macro_parameter) {
+			D_ASSERT(macro_binding->HasMatchingBinding(colref.GetColumnName()));
 			expr = macro_binding->ParamToArg(colref);
 		}
 		return;
@@ -136790,7 +137157,8 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	case ExpressionClass::SUBQUERY: {
 		// replacing parameters within a subquery is slightly different
 		auto &sq = ((SubqueryExpression &)*expr).subquery;
-		ReplaceMacroParametersRecursive(*expr, *sq->node);
+		ParsedExpressionIterator::EnumerateQueryNodeChildren(
+		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
 		break;
 	}
 	default: // fall through
@@ -136801,89 +137169,6 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
 }
 
-void ExpressionBinder::ReplaceMacroParametersRecursive(ParsedExpression &expr, TableRef &ref) {
-	switch (ref.type) {
-	case TableReferenceType::CROSS_PRODUCT: {
-		auto &cp_ref = (CrossProductRef &)ref;
-		ReplaceMacroParametersRecursive(expr, *cp_ref.left);
-		ReplaceMacroParametersRecursive(expr, *cp_ref.right);
-		break;
-	}
-	case TableReferenceType::EXPRESSION_LIST: {
-		auto &el_ref = (ExpressionListRef &)ref;
-		for (idx_t i = 0; i < el_ref.values.size(); i++) {
-			for (idx_t j = 0; j < el_ref.values[i].size(); j++) {
-				ReplaceMacroParametersRecursive(el_ref.values[i][j]);
-			}
-		}
-		break;
-	}
-	case TableReferenceType::JOIN: {
-		auto &j_ref = (JoinRef &)ref;
-		ReplaceMacroParametersRecursive(expr, *j_ref.left);
-		ReplaceMacroParametersRecursive(expr, *j_ref.right);
-		ReplaceMacroParametersRecursive(j_ref.condition);
-		break;
-	}
-	case TableReferenceType::SUBQUERY: {
-		auto &sq_ref = (SubqueryRef &)ref;
-		ReplaceMacroParametersRecursive(expr, *sq_ref.subquery->node);
-		break;
-	}
-	case TableReferenceType::TABLE_FUNCTION: {
-		auto &tf_ref = (TableFunctionRef &)ref;
-		ReplaceMacroParametersRecursive(tf_ref.function);
-		break;
-	}
-	case TableReferenceType::BASE_TABLE:
-	case TableReferenceType::EMPTY:
-		// these TableRefs do not need to be unfolded
-		break;
-	default:
-		throw NotImplementedException("TableRef type not implemented for macro's!");
-	}
-}
-
-void ExpressionBinder::ReplaceMacroParametersRecursive(ParsedExpression &expr, QueryNode &node) {
-	switch (node.type) {
-	case QueryNodeType::RECURSIVE_CTE_NODE: {
-		auto &rcte_node = (RecursiveCTENode &)node;
-		ReplaceMacroParametersRecursive(expr, *rcte_node.left);
-		ReplaceMacroParametersRecursive(expr, *rcte_node.right);
-		break;
-	}
-	case QueryNodeType::SELECT_NODE: {
-		auto &sel_node = (SelectNode &)node;
-		for (idx_t i = 0; i < sel_node.select_list.size(); i++) {
-			ReplaceMacroParametersRecursive(sel_node.select_list[i]);
-		}
-		for (idx_t i = 0; i < sel_node.groups.group_expressions.size(); i++) {
-			ReplaceMacroParametersRecursive(sel_node.groups.group_expressions[i]);
-		}
-		if (sel_node.where_clause != nullptr) {
-			ReplaceMacroParametersRecursive(sel_node.where_clause);
-		}
-		if (sel_node.having != nullptr) {
-			ReplaceMacroParametersRecursive(sel_node.having);
-		}
-
-		ReplaceMacroParametersRecursive(expr, *sel_node.from_table.get());
-		break;
-	}
-	case QueryNodeType::SET_OPERATION_NODE: {
-		auto &setop_node = (SetOperationNode &)node;
-		ReplaceMacroParametersRecursive(expr, *setop_node.left);
-		ReplaceMacroParametersRecursive(expr, *setop_node.right);
-		break;
-	}
-	default:
-		throw NotImplementedException("QueryNode type not implemented for macro's!");
-	}
-	for (auto &kv : node.cte_map) {
-		ReplaceMacroParametersRecursive(expr, *kv.second->query->node);
-	}
-}
-
 BindResult ExpressionBinder::BindMacro(FunctionExpression &function, MacroCatalogEntry *macro_func, idx_t depth,
                                        unique_ptr<ParsedExpression> *expr) {
 	auto &macro_def = *macro_func->function;
@@ -136902,7 +137187,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, MacroCatalo
 	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
 		types.push_back(LogicalType::SQLNULL);
 		auto &param = (ColumnRefExpression &)*macro_def.parameters[i];
-		names.push_back(param.column_name);
+		names.push_back(param.GetColumnName());
 	}
 	// default parameters
 	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
@@ -137826,40 +138111,6 @@ private:
 } // namespace duckdb
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/where_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ColumnAliasBinder;
-
-//! The WHERE binder is responsible for binding an expression within the WHERE clause of a SQL statement
-class WhereBinder : public ExpressionBinder {
-public:
-	WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder = nullptr);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-
-private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
-
-	ColumnAliasBinder *column_alias_binder;
-};
-
-} // namespace duckdb
 
 
 
@@ -138050,7 +138301,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		auto &expr = statement.select_list[i];
 		result->names.push_back(expr->GetName());
-		ExpressionBinder::BindTableNames(*this, *expr);
+		ExpressionBinder::QualifyColumnNames(*this, expr);
 		if (!expr->alias.empty()) {
 			alias_map[expr->alias] = i;
 			result->names[i] = expr->alias;
@@ -138104,7 +138355,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 			// if we wouldn't do this then (SELECT test.a FROM test GROUP BY a) would not work because "test.a" <> "a"
 			// hence we convert "a" -> "test.a" in the unbound expression
 			unbound_groups[i] = move(group_binder.unbound_expression);
-			ExpressionBinder::BindTableNames(*this, *unbound_groups[i]);
+			ExpressionBinder::QualifyColumnNames(*this, unbound_groups[i]);
 			info.map[unbound_groups[i].get()] = i;
 		}
 	}
@@ -138113,7 +138364,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	// bind the HAVING clause, if any
 	if (statement.having) {
 		HavingBinder having_binder(*this, context, *result, info, alias_map);
-		ExpressionBinder::BindTableNames(*this, *statement.having, &alias_map);
+		ExpressionBinder::QualifyColumnNames(*this, statement.having);
 		result->having = having_binder.Bind(statement.having);
 	}
 
@@ -139402,11 +139653,11 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	// positional parameters
 	for (idx_t i = 0; i < base.function->parameters.size(); i++) {
 		auto param = (ColumnRefExpression &)*base.function->parameters[i];
-		if (!param.table_name.empty()) {
-			throw BinderException("Invalid parameter name '%s'", param.ToString());
+		if (param.IsQualified()) {
+			throw BinderException("Invalid parameter name '%s': must be unqualified", param.ToString());
 		}
 		dummy_types.push_back(LogicalType::SQLNULL);
-		dummy_names.push_back(param.column_name);
+		dummy_names.push_back(param.GetColumnName());
 	}
 	// default parameters
 	for (auto it = base.function->default_parameters.begin(); it != base.function->default_parameters.end(); it++) {
@@ -139416,6 +139667,7 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	}
 	auto this_macro_binding = make_unique<MacroBinding>(dummy_types, dummy_names, base.name);
 	macro_binding = this_macro_binding.get();
+	ExpressionBinder::QualifyColumnNames(*this, base.function->expression);
 
 	// create a copy of the expression because we do not want to alter the original
 	auto expression = base.function->expression->Copy();
@@ -141532,8 +141784,8 @@ bool Binder::BindFunctionParameters(vector<unique_ptr<ParsedExpression>> &expres
 			auto &comp = (ComparisonExpression &)*child;
 			if (comp.left->type == ExpressionType::COLUMN_REF) {
 				auto &colref = (ColumnRefExpression &)*comp.left;
-				if (colref.table_name.empty()) {
-					parameter_name = colref.column_name;
+				if (!colref.IsQualified()) {
+					parameter_name = colref.GetColumnName();
 					child = move(comp.right);
 				}
 			}
@@ -142004,6 +142256,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
 
 
 
+
+
 #include <algorithm>
 
 namespace duckdb {
@@ -142283,6 +142537,38 @@ void Binder::AddCorrelatedColumn(const CorrelatedColumnInfo &info) {
 	}
 }
 
+bool Binder::HasMatchingBinding(const string &table_name, const string &column_name, string &error_message) {
+	string empty_schema;
+	return HasMatchingBinding(empty_schema, table_name, column_name, error_message);
+}
+
+bool Binder::HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
+                                string &error_message) {
+	Binding *binding;
+	if (macro_binding && table_name == macro_binding->alias) {
+		binding = macro_binding;
+	} else {
+		binding = bind_context.GetBinding(table_name, error_message);
+	}
+	if (!binding) {
+		return false;
+	}
+	if (!schema_name.empty()) {
+		auto table_entry = binding->GetTableEntry();
+		if (!table_entry) {
+			return false;
+		}
+		if (table_entry->schema->name != schema_name || table_entry->name != table_name) {
+			return false;
+		}
+	}
+	if (!binding->HasMatchingBinding(column_name)) {
+		error_message = binding->ColumnNotFoundError(column_name);
+		return false;
+	}
+	return true;
+}
+
 string Binder::FormatError(ParsedExpression &expr_context, const string &message) {
 	return FormatError(expr_context.query_location, message);
 }
@@ -143374,13 +143660,13 @@ string AlterBinder::UnsupportedAggregateMessage() {
 }
 
 BindResult AlterBinder::BindColumn(ColumnRefExpression &colref) {
-	if (!colref.table_name.empty() && colref.table_name != table.name) {
-		throw BinderException("Cannot reference table %s from within alter statement for table %s!", colref.table_name,
-		                      table.name);
+	if (colref.column_names.size() > 1) {
+		return BindQualifiedColumnName(colref, table.name);
 	}
-	auto idx = table.GetColumnIndex(colref.column_name, true);
+	auto idx = table.GetColumnIndex(colref.column_names[0], true);
 	if (idx == INVALID_INDEX) {
-		throw BinderException("Table does not contain column %s referenced in alter statement!", colref.column_name);
+		throw BinderException("Table does not contain column %s referenced in alter statement!",
+		                      colref.column_names[0]);
 	}
 	bound_columns.push_back(idx);
 	return BindResult(make_unique<BoundReferenceExpression>(table.columns[idx].type, bound_columns.size() - 1));
@@ -143394,9 +143680,9 @@ BindResult AlterBinder::BindColumn(ColumnRefExpression &colref) {
 
 namespace duckdb {
 
-CheckBinder::CheckBinder(Binder &binder, ClientContext &context, string table, vector<ColumnDefinition> &columns,
+CheckBinder::CheckBinder(Binder &binder, ClientContext &context, string table_p, vector<ColumnDefinition> &columns,
                          unordered_set<column_t> &bound_columns)
-    : ExpressionBinder(binder, context), table(move(table)), columns(columns), bound_columns(bound_columns) {
+    : ExpressionBinder(binder, context), table(move(table_p)), columns(columns), bound_columns(bound_columns) {
 	target_type = LogicalType::INTEGER;
 }
 
@@ -143418,18 +143704,29 @@ string CheckBinder::UnsupportedAggregateMessage() {
 	return "aggregate functions are not allowed in check constraints";
 }
 
+BindResult ExpressionBinder::BindQualifiedColumnName(ColumnRefExpression &colref, const string &table_name) {
+	idx_t struct_start = 0;
+	if (colref.column_names[0] == table_name) {
+		struct_start++;
+	}
+	auto result = make_unique_base<ParsedExpression, ColumnRefExpression>(colref.column_names.back());
+	for (idx_t i = struct_start; i + 1 < colref.column_names.size(); i++) {
+		result = CreateStructExtract(move(result), colref.column_names[i]);
+	}
+	return BindExpression(&result, 0);
+}
+
 BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
-	if (!colref.table_name.empty() && colref.table_name != table) {
-		throw BinderException("Cannot reference table %s from within check constraint for table %s!", colref.table_name,
-		                      table);
+	if (colref.column_names.size() > 1) {
+		return BindQualifiedColumnName(colref, table);
 	}
 	for (idx_t i = 0; i < columns.size(); i++) {
-		if (colref.column_name == columns[i].name) {
+		if (colref.column_names[0] == columns[i].name) {
 			bound_columns.insert(i);
 			return BindResult(make_unique<BoundReferenceExpression>(columns[i].type, i));
 		}
 	}
-	throw BinderException("Table does not contain column %s referenced in check constraint!", colref.column_name);
+	throw BinderException("Table does not contain column %s referenced in check constraint!", colref.column_names[0]);
 }
 
 } // namespace duckdb
@@ -143447,11 +143744,11 @@ ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const unordered_map<
 
 BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
                                         bool root_expression) {
-	if (!expr.table_name.empty()) {
+	if (expr.IsQualified()) {
 		return BindResult(StringUtil::Format("Alias %s cannot be qualified.", expr.ToString()));
 	}
 
-	auto alias_entry = alias_map.find(expr.column_name);
+	auto alias_entry = alias_map.find(expr.column_names[0]);
 	if (alias_entry == alias_map.end()) {
 		return BindResult(StringUtil::Format("Alias %s is not found.", expr.ToString()));
 	}
@@ -143581,13 +143878,13 @@ BindResult GroupBinder::BindColumnRef(ColumnRefExpression &colref) {
 	// first try to bind to the base columns (original tables)
 	auto result = ExpressionBinder::BindExpression(colref, 0);
 	if (result.HasError()) {
-		// failed to bind the column and the node is the root expression with depth = 0
-		// check if refers to an alias in the select clause
-		auto alias_name = colref.column_name;
-		if (!colref.table_name.empty()) {
+		if (colref.IsQualified()) {
 			// explicit table name: not an alias reference
 			return result;
 		}
+		// failed to bind the column and the node is the root expression with depth = 0
+		// check if refers to an alias in the select clause
+		auto alias_name = colref.column_names[0];
 		auto entry = alias_map.find(alias_name);
 		if (entry == alias_map.end()) {
 			// no matching alias found
@@ -143754,11 +144051,11 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		// check if we can bind it to an alias in the select list
 		auto &colref = (ColumnRefExpression &)*expr;
 		// if there is an explicit table name we can't bind to an alias
-		if (!colref.table_name.empty()) {
+		if (colref.IsQualified()) {
 			break;
 		}
 		// check the alias list
-		auto entry = alias_map.find(colref.column_name);
+		auto entry = alias_map.find(colref.column_names[0]);
 		if (entry != alias_map.end()) {
 			// it does! point it to that entry
 			return CreateProjectionReference(*expr, entry->second);
@@ -143775,7 +144072,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 	// general case
 	// first bind the table names of this entry
 	for (auto &binder : binders) {
-		ExpressionBinder::BindTableNames(*binder, *expr);
+		ExpressionBinder::QualifyColumnNames(*binder, expr);
 	}
 	// first check if the ORDER BY clause already points to an entry in the projection list
 	auto entry = projection_map.find(expr.get());
@@ -143898,8 +144195,8 @@ idx_t SelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	// first check the group alias map, if expr is a ColumnRefExpression
 	if (expr.type == ExpressionType::COLUMN_REF) {
 		auto &colref = (ColumnRefExpression &)expr;
-		if (colref.table_name.empty()) {
-			auto alias_entry = info.alias_map.find(colref.column_name);
+		if (!colref.IsQualified()) {
+			auto alias_entry = info.alias_map.find(colref.column_names[0]);
 			if (alias_entry != info.alias_map.end()) {
 				// found entry!
 				return alias_entry->second;
@@ -143934,7 +144231,7 @@ BindResult SelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t dept
 	vector<idx_t> group_indexes;
 	group_indexes.reserve(op.children.size());
 	for (auto &child : op.children) {
-		ExpressionBinder::BindTableNames(binder, *child);
+		ExpressionBinder::QualifyColumnNames(binder, child);
 		auto idx = TryBindGroup(*child, depth);
 		if (idx == INVALID_INDEX) {
 			return BindResult(binder.FormatError(
@@ -144104,7 +144401,7 @@ bool ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr)
 	bool success = false;
 	while (!active_binders.empty()) {
 		auto &next_binder = active_binders.back();
-		ExpressionBinder::BindTableNames(next_binder->binder, *expr);
+		ExpressionBinder::QualifyColumnNames(next_binder->binder, expr);
 		auto bind_result = next_binder->Bind(&expr, depth);
 		if (bind_result.empty()) {
 			success = true;
@@ -144265,33 +144562,6 @@ string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, b
 	}
 }
 
-void ExpressionBinder::BindTableNames(Binder &binder, ParsedExpression &expr, unordered_map<string, idx_t> *alias_map) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
-		if (colref.table_name.empty()) {
-			// no table name: find a binding that contains this
-			if (binder.macro_binding != nullptr && binder.macro_binding->HasMatchingBinding(colref.column_name)) {
-				// macro parameters get priority
-				colref.table_name = binder.macro_binding->alias;
-			} else {
-				colref.table_name = binder.bind_context.GetMatchingBinding(colref.column_name);
-			}
-		}
-		binder.bind_context.BindColumn(colref, 0);
-	} else if (expr.type == ExpressionType::POSITIONAL_REFERENCE) {
-		auto &ref = (PositionalReferenceExpression &)expr;
-		if (ref.alias.empty()) {
-			string table_name, column_name;
-			auto error = binder.bind_context.BindColumn(ref, table_name, column_name);
-			if (error.empty()) {
-				ref.alias = column_name;
-			}
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { BindTableNames(binder, (ParsedExpression &)child, alias_map); });
-}
-
 } // namespace duckdb
 
 
@@ -145354,6 +145624,7 @@ bool LogicalFilter::SplitPredicates(vector<unique_ptr<Expression>> &expressions)
 
 
 
+
 namespace duckdb {
 
 LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
@@ -145366,6 +145637,10 @@ string LogicalGet::GetName() const {
 	return StringUtil::Upper(function.name);
 }
 
+TableCatalogEntry *LogicalGet::GetTable() const {
+	return TableScanFunction::GetTableEntry(function, bind_data.get());
+}
+
 string LogicalGet::ParamsToString() const {
 	string result;
 	for (auto &kv : table_filters.filters) {
@@ -146405,16 +146680,27 @@ bool Binding::TryGetBindingIndex(const string &column_name, column_t &result) {
 	return false;
 }
 
+column_t Binding::GetBindingIndex(const string &column_name) {
+	column_t result;
+	if (!TryGetBindingIndex(column_name, result)) {
+		throw InternalException("Binding index for column \"%s\" not found", column_name);
+	}
+	return result;
+}
+
 bool Binding::HasMatchingBinding(const string &column_name) {
 	column_t result;
 	return TryGetBindingIndex(column_name, result);
 }
 
+string Binding::ColumnNotFoundError(const string &column_name) const {
+	return StringUtil::Format("Values list \"%s\" does not have a column named \"%s\"", alias, column_name);
+}
+
 BindResult Binding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	column_t column_index;
-	if (!TryGetBindingIndex(colref.column_name, column_index)) {
-		return BindResult(StringUtil::Format("Values list \"%s\" does not have a column named \"%s\"", alias.c_str(),
-		                                     colref.column_name.c_str()));
+	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
+		return BindResult(ColumnNotFoundError(colref.GetColumnName()));
 	}
 	ColumnBinding binding;
 	binding.table_index = index;
@@ -146426,6 +146712,10 @@ BindResult Binding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	return BindResult(make_unique<BoundColumnRefExpression>(colref.GetName(), sql_type, binding, depth));
 }
 
+TableCatalogEntry *Binding::GetTableEntry() {
+	return nullptr;
+}
+
 TableBinding::TableBinding(const string &alias, vector<LogicalType> types_p, vector<string> names_p, LogicalGet &get,
                            idx_t index, bool add_row_id)
     : Binding(alias, move(types_p), move(names_p), index), get(get) {
@@ -146437,10 +146727,10 @@ TableBinding::TableBinding(const string &alias, vector<LogicalType> types_p, vec
 }
 
 BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
+	auto &column_name = colref.GetColumnName();
 	column_t column_index;
-	if (!TryGetBindingIndex(colref.column_name, column_index)) {
-		return BindResult(StringUtil::Format("Table \"%s\" does not have a column named \"%s\"", colref.table_name,
-		                                     colref.column_name));
+	if (!TryGetBindingIndex(column_name, column_index)) {
+		return BindResult(ColumnNotFoundError(column_name));
 	}
 	// fetch the type of the column
 	LogicalType col_type;
@@ -146474,15 +146764,22 @@ BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	return BindResult(make_unique<BoundColumnRefExpression>(colref.GetName(), col_type, binding, depth));
 }
 
+TableCatalogEntry *TableBinding::GetTableEntry() {
+	return get.GetTable();
+}
+
+string TableBinding::ColumnNotFoundError(const string &column_name) const {
+	return StringUtil::Format("Table \"%s\" does not have a column named \"%s\"", alias, column_name);
+}
+
 MacroBinding::MacroBinding(vector<LogicalType> types_p, vector<string> names_p, string macro_name_p)
-    : Binding("0_macro_parameters", move(types_p), move(names_p), -1), macro_name(move(macro_name_p)) {
+    : Binding(MacroBinding::MACRO_NAME, move(types_p), move(names_p), -1), macro_name(move(macro_name_p)) {
 }
 
 BindResult MacroBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	column_t column_index;
-	if (!TryGetBindingIndex(colref.column_name, column_index)) {
-		return BindResult(
-		    StringUtil::Format("Macro \"%s\" does not have a parameter named \"%s\"", macro_name, colref.column_name));
+	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
+		throw InternalException("Column %s not found in macro", colref.GetColumnName());
 	}
 	ColumnBinding binding;
 	binding.table_index = index;
@@ -146494,8 +146791,8 @@ BindResult MacroBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 
 unique_ptr<ParsedExpression> MacroBinding::ParamToArg(ColumnRefExpression &colref) {
 	column_t column_index;
-	if (!TryGetBindingIndex(colref.column_name, column_index)) {
-		throw BinderException("Macro \"%s\" does not have a parameter named \"%s\"", macro_name, colref.column_name);
+	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
+		throw InternalException("Column %s not found in macro", colref.GetColumnName());
 	}
 	auto arg = arguments[column_index]->Copy();
 	arg->alias = colref.alias;
@@ -153469,7 +153766,7 @@ string ValidityStatistics::ToString() {
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 27;
+const uint64_t VERSION_NUMBER = 28;
 
 } // namespace duckdb
 
@@ -212146,7 +212443,6 @@ unsigned char *unicode_to_utf8(pg_wchar c, unsigned char *utf8string);
 
 // max parse tree size approx 100 MB, should be enough
 #define PG_MALLOC_SIZE 10240
-#define PG_MALLOC_LIMIT 1000
 
 namespace duckdb_libpgquery {
 
@@ -212158,7 +212454,8 @@ struct pg_parser_state_str {
 
 	size_t malloc_pos;
 	size_t malloc_ptr_idx;
-	char *malloc_ptrs[PG_MALLOC_LIMIT];
+	char **malloc_ptrs;
+	size_t malloc_ptr_size;
 };
 
 static __thread parser_state pg_parser_state;
@@ -212168,8 +212465,13 @@ __thread PGNode *duckdb_newNodeMacroHolder;
 #endif
 
 static void allocate_new(parser_state *state, size_t n) {
-	if (state->malloc_ptr_idx + 1 >= PG_MALLOC_LIMIT) {
-		throw std::runtime_error("Memory allocation failure");
+	if (state->malloc_ptr_idx >= state->malloc_ptr_size) {
+		size_t new_size = state->malloc_ptr_size * 2;
+		auto new_malloc_ptrs = (char **) malloc(sizeof(char *) * new_size);
+		memcpy(new_malloc_ptrs, state->malloc_ptrs, state->malloc_ptr_size * sizeof(char*));
+		free(state->malloc_ptrs);
+		state->malloc_ptr_size = new_size;
+		state->malloc_ptrs = new_malloc_ptrs;
 	}
 	if (n < PG_MALLOC_SIZE) {
 		n = PG_MALLOC_SIZE;
@@ -212200,6 +212502,8 @@ void pg_parser_init() {
 	pg_parser_state.pg_err_code = PGUNDEFINED;
 	pg_parser_state.pg_err_msg[0] = '\0';
 
+	pg_parser_state.malloc_ptr_size = 4;
+	pg_parser_state.malloc_ptrs = (char **) malloc(sizeof(char *) * pg_parser_state.malloc_ptr_size);
 	pg_parser_state.malloc_ptr_idx = 0;
 	allocate_new(&pg_parser_state, 1);
 }
@@ -212209,8 +212513,16 @@ void pg_parser_parse(const char *query, parse_result *res) {
 	try {
 		res->parse_tree = duckdb_libpgquery::raw_parser(query);
 		res->success = pg_parser_state.pg_err_code == PGUNDEFINED;
-	} catch (...) {
+	} catch (std::exception &ex) {
 		res->success = false;
+		// copy the error message of the exception
+		auto error_message = ex.what();
+		uint32_t pos = 0;
+		while(pos < 1023 && error_message[pos]) {
+			pg_parser_state.pg_err_msg[pos] = error_message[pos];
+			pos++;
+		}
+		pg_parser_state.pg_err_msg[pos] = '\0';
 	}
 	res->error_message = pg_parser_state.pg_err_msg;
 	res->error_location = pg_parser_state.pg_err_pos;
@@ -212224,6 +212536,7 @@ void pg_parser_cleanup() {
 			pg_parser_state.malloc_ptrs[ptr_idx] = nullptr;
 		}
 	}
+	free(pg_parser_state.malloc_ptrs);
 }
 
 int ereport(int code, ...) {