duckdb 0.3.2-dev5.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(
@@ -18315,7 +18349,7 @@ struct RegexpFun {
 
 struct SubstringFun {
 	static void RegisterFunction(BuiltinFunctions &set);
-	static string_t SubstringScalarFunction(Vector &result, string_t input, int32_t offset, int32_t length);
+	static string_t SubstringScalarFunction(Vector &result, string_t input, int64_t offset, int64_t length);
 };
 
 struct PrintfFun {
@@ -37228,6 +37262,52 @@ bool Interval::GreaterThanEquals(interval_t left, interval_t right) {
 	return GreaterThan(left, right) || Equals(left, right);
 }
 
+date_t Interval::Add(date_t left, interval_t right) {
+	date_t result;
+	if (right.months != 0) {
+		int32_t year, month, day;
+		Date::Convert(left, year, month, day);
+		int32_t year_diff = right.months / Interval::MONTHS_PER_YEAR;
+		year += year_diff;
+		month += right.months - year_diff * Interval::MONTHS_PER_YEAR;
+		if (month > Interval::MONTHS_PER_YEAR) {
+			year++;
+			month -= Interval::MONTHS_PER_YEAR;
+		} else if (month <= 0) {
+			year--;
+			month += Interval::MONTHS_PER_YEAR;
+		}
+		day = MinValue<int32_t>(day, Date::MonthDays(year, month));
+		result = Date::FromDate(year, month, day);
+	} else {
+		result = left;
+	}
+	if (right.days != 0) {
+		if (!TryAddOperator::Operation(result.days, right.days, result.days)) {
+			throw OutOfRangeException("Date out of range");
+		}
+	}
+	if (right.micros != 0) {
+		if (!TryAddOperator::Operation(result.days, int32_t(right.micros / Interval::MICROS_PER_DAY), result.days)) {
+			throw OutOfRangeException("Date out of range");
+		}
+	}
+	return result;
+}
+
+dtime_t Interval::Add(dtime_t left, interval_t right, date_t &date) {
+	int64_t diff = right.micros - ((right.micros / Interval::MICROS_PER_DAY) * Interval::MICROS_PER_DAY);
+	left += diff;
+	if (left.micros >= Interval::MICROS_PER_DAY) {
+		left.micros -= Interval::MICROS_PER_DAY;
+		date.days++;
+	} else if (left.micros < 0) {
+		left.micros += Interval::MICROS_PER_DAY;
+		date.days--;
+	}
+	return left;
+}
+
 } // namespace duckdb
 
 
@@ -46204,7 +46284,38 @@ void FillEnumResultTemplate(Vector &source, Vector &result, idx_t count) {
 	}
 }
 
-static bool EnumCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
+void EnumToVarchar(Vector &source, Vector &result, idx_t count, PhysicalType enum_physical_type) {
+	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(source.GetVectorType());
+	} else {
+		result.SetVectorType(VectorType::FLAT_VECTOR);
+	}
+	for (idx_t i = 0; i < count; i++) {
+		auto src_val = source.GetValue(i);
+		if (src_val.is_null) {
+			result.SetValue(i, Value());
+			continue;
+		}
+		auto str_vec = EnumType::GetValuesInsertOrder(source.GetType());
+		uint64_t enum_idx;
+		switch (enum_physical_type) {
+		case PhysicalType::UINT8:
+			enum_idx = src_val.value_.utinyint;
+			break;
+		case PhysicalType::UINT16:
+			enum_idx = src_val.value_.usmallint;
+			break;
+		case PhysicalType::UINT32:
+			enum_idx = src_val.value_.uinteger;
+			break;
+		default:
+			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
+		}
+		result.SetValue(i, Value(str_vec[enum_idx]));
+	}
+}
+
+static bool EnumCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message, bool strict) {
 	auto enum_physical_type = source.GetType().InternalType();
 	switch (result.GetType().id()) {
 	case LogicalTypeId::ENUM: {
@@ -46225,38 +46336,17 @@ static bool EnumCastSwitch(Vector &source, Vector &result, idx_t count, string *
 		break;
 	}
 	case LogicalTypeId::VARCHAR: {
-		if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(source.GetVectorType());
-		} else {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto src_val = source.GetValue(i);
-			if (src_val.is_null) {
-				result.SetValue(i, Value());
-				continue;
-			}
-			auto str_vec = EnumType::GetValuesInsertOrder(source.GetType());
-			uint64_t enum_idx;
-			switch (enum_physical_type) {
-			case PhysicalType::UINT8:
-				enum_idx = src_val.value_.utinyint;
-				break;
-			case PhysicalType::UINT16:
-				enum_idx = src_val.value_.usmallint;
-				break;
-			case PhysicalType::UINT32:
-				enum_idx = src_val.value_.uinteger;
-				break;
-			default:
-				throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-			}
-			result.SetValue(i, Value(str_vec[enum_idx]));
-		}
+		EnumToVarchar(source, result, count, enum_physical_type);
+		break;
+	}
+	default: {
+		// Cast to varchar
+		Vector varchar_cast(LogicalType::VARCHAR, count);
+		EnumToVarchar(source, varchar_cast, count, enum_physical_type);
+		// Try to cast from varchar to whatever we wanted before
+		VectorOperations::TryCast(varchar_cast, result, count, error_message, strict);
 		break;
 	}
-	default:
-		throw InternalException("Cast from Enum is not allowed");
 	}
 	return true;
 }
@@ -46371,7 +46461,7 @@ bool VectorOperations::TryCast(Vector &source, Vector &result, idx_t count, stri
 	case LogicalTypeId::LIST:
 		return ListCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::ENUM:
-		return EnumCastSwitch(source, result, count, error_message);
+		return EnumCastSwitch(source, result, count, error_message, strict);
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -49644,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);
 
@@ -58771,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
@@ -61172,15 +61264,9 @@ struct BufferedCSVReaderOptions {
 	//! Whether or not a type format is specified
 	std::map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
 
-	std::string toString() const {
-		return "DELIMITER='" + delimiter + (has_delimiter ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
-		       ", QUOTE='" + quote + (has_quote ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
-		       ", ESCAPE='" + escape + (has_escape ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
-		       ", HEADER=" + std::to_string(header) +
-		       (has_header ? "" : (auto_detect ? " (auto detected)" : "' (default)")) +
-		       ", SAMPLE_SIZE=" + std::to_string(sample_chunk_size * sample_chunks) +
-		       ", ALL_VARCHAR=" + std::to_string(all_varchar);
-	}
+	void SetDelimiter(const string &delimiter);
+
+	std::string ToString() const;
 };
 
 enum class ParserMode : uint8_t { PARSING = 0, SNIFFING_DIALECT = 1, SNIFFING_DATATYPES = 2, PARSING_HEADER = 3 };
@@ -61333,6 +61419,24 @@ private:
 
 namespace duckdb {
 
+void BufferedCSVReaderOptions::SetDelimiter(const string &input) {
+	this->delimiter = StringUtil::Replace(input, "\\t", "\t");
+	this->has_delimiter = true;
+	if (input.empty()) {
+		throw BinderException("DELIM or SEP must not be empty");
+	}
+}
+
+std::string BufferedCSVReaderOptions::ToString() const {
+	return "DELIMITER='" + delimiter + (has_delimiter ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
+	       ", QUOTE='" + quote + (has_quote ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
+	       ", ESCAPE='" + escape + (has_escape ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
+	       ", HEADER=" + std::to_string(header) +
+	       (has_header ? "" : (auto_detect ? " (auto detected)" : "' (default)")) +
+	       ", SAMPLE_SIZE=" + std::to_string(sample_chunk_size * sample_chunks) +
+	       ", ALL_VARCHAR=" + std::to_string(all_varchar);
+}
+
 static string GetLineNumberStr(idx_t linenr, bool linenr_estimated) {
 	string estimated = (linenr_estimated ? string(" (estimated)") : string(""));
 	return to_string(linenr + 1) + estimated;
@@ -62146,7 +62250,7 @@ vector<LogicalType> BufferedCSVReader::RefineTypeDetection(const vector<LogicalT
 		if (requested_types.size() != options.num_cols) {
 			throw InvalidInputException(
 			    "Error while determining column types: found %lld columns but expected %d. (%s)", options.num_cols,
-			    requested_types.size(), options.toString());
+			    requested_types.size(), options.ToString());
 		} else {
 			detected_types = requested_types;
 		}
@@ -62404,7 +62508,7 @@ in_quotes:
 	} while (ReadBuffer(start));
 	// still in quoted state at the end of the file, error:
 	error_message = StringUtil::Format("Error in file \"%s\" on line %s: unterminated quotes. (%s)", options.file_path,
-	                                   GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+	                                   GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 	return false;
 unquote:
 	/* state: unquote */
@@ -62434,7 +62538,7 @@ unquote:
 				error_message = StringUtil::Format(
 				    "Error in file \"%s\" on line %s: quote should be followed by end of value, end "
 				    "of row or another quote. (%s)",
-				    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+				    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 				return false;
 			}
 			if (delimiter_pos == options.delimiter.size()) {
@@ -62451,7 +62555,7 @@ unquote:
 	} while (ReadBuffer(start));
 	error_message = StringUtil::Format(
 	    "Error in file \"%s\" on line %s: quote should be followed by end of value, end of row or another quote. (%s)",
-	    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+	    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 	return false;
 handle_escape:
 	escape_pos = 0;
@@ -62466,7 +62570,7 @@ handle_escape:
 			if (count > escape_pos && count > quote_pos) {
 				error_message = StringUtil::Format(
 				    "Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)",
-				    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+				    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 				return false;
 			}
 			if (quote_pos == options.quote.size() || escape_pos == options.escape.size()) {
@@ -62477,7 +62581,7 @@ handle_escape:
 	} while (ReadBuffer(start));
 	error_message =
 	    StringUtil::Format("Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)",
-	                       options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+	                       options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 	return false;
 carriage_return:
 	/* state: carriage_return */
@@ -62609,7 +62713,7 @@ in_quotes:
 	} while (ReadBuffer(start));
 	// still in quoted state at the end of the file, error:
 	throw InvalidInputException("Error in file \"%s\" on line %s: unterminated quotes. (%s)", options.file_path,
-	                            GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+	                            GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 unquote:
 	/* state: unquote */
 	// this state handles the state directly after we unquote
@@ -62636,7 +62740,7 @@ unquote:
 		error_message = StringUtil::Format(
 		    "Error in file \"%s\" on line %s: quote should be followed by end of value, end of "
 		    "row or another quote. (%s)",
-		    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+		    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 		return false;
 	}
 handle_escape:
@@ -62646,13 +62750,13 @@ handle_escape:
 	if (position >= buffer_size && !ReadBuffer(start)) {
 		error_message = StringUtil::Format(
 		    "Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)", options.file_path,
-		    GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+		    GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 		return false;
 	}
 	if (buffer[position] != options.quote[0] && buffer[position] != options.escape[0]) {
 		error_message = StringUtil::Format(
 		    "Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)", options.file_path,
-		    GetLineNumberStr(linenr, linenr_estimated).c_str(), options.toString());
+		    GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 		return false;
 	}
 	// escape was followed by quote or escape, go back to quoted state
@@ -62792,7 +62896,7 @@ void BufferedCSVReader::AddValue(char *str_val, idx_t length, idx_t &column, vec
 	if (column >= sql_types.size()) {
 		throw InvalidInputException("Error on line %s: expected %lld values per row, but got more. (%s)",
 		                            GetLineNumberStr(linenr, linenr_estimated).c_str(), sql_types.size(),
-		                            options.toString());
+		                            options.ToString());
 	}
 
 	// insert the line number into the chunk
@@ -62847,7 +62951,7 @@ bool BufferedCSVReader::AddRow(DataChunk &insert_chunk, idx_t &column) {
 	if (column < sql_types.size() && mode != ParserMode::SNIFFING_DIALECT) {
 		throw InvalidInputException("Error on line %s: expected %lld values per row, but got %d. (%s)",
 		                            GetLineNumberStr(linenr, linenr_estimated).c_str(), sql_types.size(), column,
-		                            options.toString());
+		                            options.ToString());
 	}
 
 	if (mode == ParserMode::SNIFFING_DIALECT) {
@@ -62900,7 +63004,7 @@ void BufferedCSVReader::Flush(DataChunk &insert_chunk) {
 						throw InvalidInputException("Error in file \"%s\" between line %llu and %llu in column \"%s\": "
 						                            "file is not valid UTF8. Parser options: %s",
 						                            options.file_path, linenr - parse_chunk.size(), linenr, col_name,
-						                            options.toString());
+						                            options.ToString());
 					}
 				}
 			}
@@ -62934,11 +63038,11 @@ void BufferedCSVReader::Flush(DataChunk &insert_chunk) {
 					                            "(SAMPLE_SIZE=X [X rows] or SAMPLE_SIZE=-1 [all rows]), "
 					                            "or skipping column conversion (ALL_VARCHAR=1)",
 					                            error_message, col_name, linenr - parse_chunk.size() + 1, linenr,
-					                            options.toString());
+					                            options.ToString());
 				} else {
 					throw InvalidInputException("%s between line %llu and %llu in column %s. Parser options: %s ",
 					                            error_message, linenr - parse_chunk.size(), linenr, col_name,
-					                            options.toString());
+					                            options.ToString());
 				}
 			}
 		}
@@ -68409,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;
@@ -78943,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());
@@ -80733,7 +80839,7 @@ int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
 template <>
 int64_t DatePart::MicrosecondsOperator::Operation(interval_t input) {
 	// remove everything but the second & microsecond part
-	return input.micros;
+	return input.micros % Interval::MICROS_PER_MINUTE;
 }
 
 template <>
@@ -80813,8 +80919,17 @@ int64_t DatePart::EpochOperator::Operation(timestamp_t input) {
 
 template <>
 int64_t DatePart::EpochOperator::Operation(interval_t input) {
-	auto secs = SecondsOperator::Operation<interval_t, int64_t>(input);
-	return (input.months * Interval::DAYS_PER_MONTH + input.days) * Interval::SECS_PER_DAY + secs;
+	int64_t interval_years = input.months / Interval::MONTHS_PER_YEAR;
+	int64_t interval_days;
+	interval_days = Interval::DAYS_PER_YEAR * interval_years;
+	interval_days += Interval::DAYS_PER_MONTH * (input.months % Interval::MONTHS_PER_YEAR);
+	interval_days += input.days;
+	int64_t interval_epoch;
+	interval_epoch = interval_days * Interval::SECS_PER_DAY;
+	// we add 0.25 days per year to sort of account for leap days
+	interval_epoch += interval_years * (Interval::SECS_PER_DAY / 4);
+	interval_epoch += input.micros / Interval::MICROS_PER_SEC;
+	return interval_epoch;
 }
 
 template <>
@@ -86034,36 +86149,7 @@ date_t AddOperator::Operation(int32_t left, date_t right) {
 
 template <>
 date_t AddOperator::Operation(date_t left, interval_t right) {
-	date_t result;
-	if (right.months != 0) {
-		int32_t year, month, day;
-		Date::Convert(left, year, month, day);
-		int32_t year_diff = right.months / Interval::MONTHS_PER_YEAR;
-		year += year_diff;
-		month += right.months - year_diff * Interval::MONTHS_PER_YEAR;
-		if (month > Interval::MONTHS_PER_YEAR) {
-			year++;
-			month -= Interval::MONTHS_PER_YEAR;
-		} else if (month <= 0) {
-			year--;
-			month += Interval::MONTHS_PER_YEAR;
-		}
-		day = MinValue<int32_t>(day, Date::MonthDays(year, month));
-		result = Date::FromDate(year, month, day);
-	} else {
-		result = left;
-	}
-	if (right.days != 0) {
-		if (!TryAddOperator::Operation(result.days, right.days, result.days)) {
-			throw OutOfRangeException("Date out of range");
-		}
-	}
-	if (right.micros != 0) {
-		if (!TryAddOperator::Operation(result.days, int32_t(right.micros / Interval::MICROS_PER_DAY), result.days)) {
-			throw OutOfRangeException("Date out of range");
-		}
-	}
-	return result;
+	return Interval::Add(left, right);
 }
 
 template <>
@@ -86071,26 +86157,13 @@ date_t AddOperator::Operation(interval_t left, date_t right) {
 	return AddOperator::Operation<date_t, interval_t, date_t>(right, left);
 }
 
-dtime_t AddIntervalToTimeOperation(dtime_t left, interval_t right, date_t &date) {
-	int64_t diff = right.micros - ((right.micros / Interval::MICROS_PER_DAY) * Interval::MICROS_PER_DAY);
-	left += diff;
-	if (left.micros >= Interval::MICROS_PER_DAY) {
-		left.micros -= Interval::MICROS_PER_DAY;
-		date.days++;
-	} else if (left.micros < 0) {
-		left.micros += Interval::MICROS_PER_DAY;
-		date.days--;
-	}
-	return left;
-}
-
 template <>
 timestamp_t AddOperator::Operation(timestamp_t left, interval_t right) {
 	date_t date;
 	dtime_t time;
 	Timestamp::Convert(left, date, time);
-	auto new_date = AddOperator::Operation<date_t, interval_t, date_t>(date, right);
-	auto new_time = AddIntervalToTimeOperation(time, right, new_date);
+	auto new_date = Interval::Add(date, right);
+	auto new_time = Interval::Add(time, right, new_date);
 	return Timestamp::FromDatetime(new_date, new_time);
 }
 
@@ -86223,7 +86296,7 @@ hugeint_t DecimalAddOverflowCheck::Operation(hugeint_t left, hugeint_t right) {
 template <>
 dtime_t AddTimeOperator::Operation(dtime_t left, interval_t right) {
 	date_t date(0);
-	return AddIntervalToTimeOperation(left, right, date);
+	return Interval::Add(left, right, date);
 }
 
 template <>
@@ -92175,7 +92248,7 @@ string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t
 	return SubstringSlice(result, input_data, start, end - start);
 }
 
-string_t SubstringFun::SubstringScalarFunction(Vector &result, string_t input, int32_t offset, int32_t length) {
+string_t SubstringFun::SubstringScalarFunction(Vector &result, string_t input, int64_t offset, int64_t length) {
 	auto input_data = input.GetDataUnsafe();
 	auto input_size = input.GetSize();
 
@@ -92242,16 +92315,16 @@ static void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &r
 	if (args.ColumnCount() == 3) {
 		auto &length_vector = args.data[2];
 
-		TernaryExecutor::Execute<string_t, int32_t, int32_t, string_t>(
+		TernaryExecutor::Execute<string_t, int64_t, int64_t, string_t>(
 		    input_vector, offset_vector, length_vector, result, args.size(),
-		    [&](string_t input_string, int32_t offset, int32_t length) {
+		    [&](string_t input_string, int64_t offset, int64_t length) {
 			    return SubstringFun::SubstringScalarFunction(result, input_string, offset, length);
 		    });
 	} else {
-		BinaryExecutor::Execute<string_t, int32_t, string_t>(
-		    input_vector, offset_vector, result, args.size(), [&](string_t input_string, int32_t offset) {
+		BinaryExecutor::Execute<string_t, int64_t, string_t>(
+		    input_vector, offset_vector, result, args.size(), [&](string_t input_string, int64_t offset) {
 			    return SubstringFun::SubstringScalarFunction(result, input_string, offset,
-			                                                 NumericLimits<int32_t>::Maximum());
+			                                                 NumericLimits<int64_t>::Maximum() - offset);
 		    });
 	}
 }
@@ -92262,15 +92335,15 @@ static void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vect
 	if (args.ColumnCount() == 3) {
 		auto &length_vector = args.data[2];
 
-		TernaryExecutor::Execute<string_t, int32_t, int32_t, string_t>(
+		TernaryExecutor::Execute<string_t, int64_t, int64_t, string_t>(
 		    input_vector, offset_vector, length_vector, result, args.size(),
-		    [&](string_t input_string, int32_t offset, int32_t length) {
+		    [&](string_t input_string, int64_t offset, int64_t length) {
 			    return SubstringASCII(result, input_string, offset, length);
 		    });
 	} else {
-		BinaryExecutor::Execute<string_t, int32_t, string_t>(
-		    input_vector, offset_vector, result, args.size(), [&](string_t input_string, int32_t offset) {
-			    return SubstringASCII(result, input_string, offset, NumericLimits<int32_t>::Maximum());
+		BinaryExecutor::Execute<string_t, int64_t, string_t>(
+		    input_vector, offset_vector, result, args.size(), [&](string_t input_string, int64_t offset) {
+			    return SubstringASCII(result, input_string, offset, NumericLimits<int64_t>::Maximum() - offset);
 		    });
 	}
 }
@@ -92292,10 +92365,10 @@ static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context
 
 void SubstringFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet substr("substring");
-	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::INTEGER},
+	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},
 	                                  LogicalType::VARCHAR, SubstringFunction, false, nullptr, nullptr,
 	                                  SubstringPropagateStats));
-	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::VARCHAR,
+	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
 	                                  SubstringFunction, false, nullptr, nullptr, SubstringPropagateStats));
 	set.AddFunction(substr);
 	substr.name = "substr";
@@ -94477,11 +94550,7 @@ static int64_t ParseInteger(vector<Value> &set) {
 //===--------------------------------------------------------------------===//
 static bool ParseBaseOption(BufferedCSVReaderOptions &options, string &loption, vector<Value> &set) {
 	if (StringUtil::StartsWith(loption, "delim") || StringUtil::StartsWith(loption, "sep")) {
-		options.delimiter = ParseString(set);
-		options.has_delimiter = true;
-		if (options.delimiter.length() == 0) {
-			throw BinderException("DELIM or SEP must not be empty");
-		}
+		options.SetDelimiter(ParseString(set));
 	} else if (loption == "quote") {
 		options.quote = ParseString(set);
 		options.has_quote = true;
@@ -95766,8 +95835,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 		if (kv.first == "auto_detect") {
 			options.auto_detect = kv.second.value_.boolean;
 		} else if (kv.first == "sep" || kv.first == "delim") {
-			options.delimiter = kv.second.str_value;
-			options.has_delimiter = true;
+			options.SetDelimiter(kv.second.str_value);
 		} else if (kv.first == "header") {
 			options.header = kv.second.value_.boolean;
 			options.has_header = true;
@@ -98679,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
 
 
@@ -106452,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 {
@@ -115073,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++) {
@@ -121749,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(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();
 }
 
-ColumnRefExpression::ColumnRefExpression(string column_name) : ColumnRefExpression(move(column_name), string()) {
+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);
 }
 
@@ -123541,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,
@@ -123676,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
 
 
@@ -129322,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
 
 
@@ -130456,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
 
 
 
@@ -130534,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
 
 
 
@@ -130833,13 +131042,6 @@ unique_ptr<TableRef> TableFunctionRef::Copy() {
 
 
 
-
-
-
-
-
-
-
 namespace duckdb {
 
 string TableRef::ToString() const {
@@ -131220,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);
@@ -131912,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) {
@@ -135570,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()) {
@@ -135595,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);
 	}
@@ -136392,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;
 }
@@ -136740,11 +137135,6 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth)
 
 
 
-
-
-
-
-
 namespace duckdb {
 
 void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr) {
@@ -136752,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;
@@ -136760,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
@@ -136771,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;
@@ -136872,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++) {
@@ -137796,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
 
 
 
@@ -138020,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;
@@ -138074,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;
 		}
 	}
@@ -138083,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);
 	}
 
@@ -139372,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++) {
@@ -139386,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();
@@ -141502,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);
 				}
 			}
@@ -141974,6 +142256,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
 
 
 
+
+
 #include <algorithm>
 
 namespace duckdb {
@@ -142253,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);
 }
@@ -143344,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));
@@ -143364,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;
 }
 
@@ -143388,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
@@ -143417,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()));
 	}
@@ -143551,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
@@ -143724,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);
@@ -143745,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());
@@ -143868,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;
@@ -143904,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(
@@ -144074,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;
@@ -144235,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
 
 
@@ -145324,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,
@@ -145336,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) {
@@ -146375,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;
@@ -146396,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) {
@@ -146407,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;
@@ -146444,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;
@@ -146464,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;
@@ -153439,7 +153766,7 @@ string ValidityStatistics::ToString() {
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 27;
+const uint64_t VERSION_NUMBER = 28;
 
 } // namespace duckdb
 
@@ -212116,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 {
 
@@ -212128,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;
@@ -212138,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;
@@ -212170,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);
 }
@@ -212179,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;
@@ -212194,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, ...) {