duckdb 0.6.1-dev12.0 → 0.6.1-dev131.0

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "7fbaefc8a1"
-#define DUCKDB_VERSION "v0.6.1-dev12"
+#define DUCKDB_SOURCE_ID "799db99fc3"
+#define DUCKDB_VERSION "v0.6.1-dev131"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -677,124 +677,6 @@ class Value;
 class TypeCatalogEntry;
 class Vector;
 class ClientContext;
-//! Type used to represent dates (days since 1970-01-01)
-struct date_t { // NOLINT
-	int32_t days;
-
-	date_t() = default;
-	explicit inline date_t(int32_t days_p) : days(days_p) {}
-
-	// explicit conversion
-	explicit inline operator int32_t() const {return days;}
-
-	// comparison operators
-	inline bool operator==(const date_t &rhs) const {return days == rhs.days;};
-	inline bool operator!=(const date_t &rhs) const {return days != rhs.days;};
-	inline bool operator<=(const date_t &rhs) const {return days <= rhs.days;};
-	inline bool operator<(const date_t &rhs) const {return days < rhs.days;};
-	inline bool operator>(const date_t &rhs) const {return days > rhs.days;};
-	inline bool operator>=(const date_t &rhs) const {return days >= rhs.days;};
-
-	// arithmetic operators
-	inline date_t operator+(const int32_t &days) const {return date_t(this->days + days);};
-	inline date_t operator-(const int32_t &days) const {return date_t(this->days - days);};
-
-	// in-place operators
-	inline date_t &operator+=(const int32_t &days) {this->days += days; return *this;};
-	inline date_t &operator-=(const int32_t &days) {this->days -= days; return *this;};
-
-	// special values
-	static inline date_t infinity() {return date_t(std::numeric_limits<int32_t>::max()); } // NOLINT
-	static inline date_t ninfinity() {return date_t(-std::numeric_limits<int32_t>::max()); } // NOLINT
-	static inline date_t epoch() {return date_t(0); } // NOLINT
-};
-
-//! Type used to represent time (microseconds)
-struct dtime_t { // NOLINT
-	int64_t micros;
-
-	dtime_t() = default;
-	explicit inline dtime_t(int64_t micros_p) : micros(micros_p) {}
-	inline dtime_t& operator=(int64_t micros_p) {micros = micros_p; return *this;}
-
-	// explicit conversion
-	explicit inline operator int64_t() const {return micros;}
-	explicit inline operator double() const {return micros;}
-
-	// comparison operators
-	inline bool operator==(const dtime_t &rhs) const {return micros == rhs.micros;};
-	inline bool operator!=(const dtime_t &rhs) const {return micros != rhs.micros;};
-	inline bool operator<=(const dtime_t &rhs) const {return micros <= rhs.micros;};
-	inline bool operator<(const dtime_t &rhs) const {return micros < rhs.micros;};
-	inline bool operator>(const dtime_t &rhs) const {return micros > rhs.micros;};
-	inline bool operator>=(const dtime_t &rhs) const {return micros >= rhs.micros;};
-
-	// arithmetic operators
-	inline dtime_t operator+(const int64_t &micros) const {return dtime_t(this->micros + micros);};
-	inline dtime_t operator+(const double &micros) const {return dtime_t(this->micros + int64_t(micros));};
-	inline dtime_t operator-(const int64_t &micros) const {return dtime_t(this->micros - micros);};
-	inline dtime_t operator*(const idx_t &copies) const {return dtime_t(this->micros * copies);};
-	inline dtime_t operator/(const idx_t &copies) const {return dtime_t(this->micros / copies);};
-	inline int64_t operator-(const dtime_t &other) const {return this->micros - other.micros;};
-
-	// in-place operators
-	inline dtime_t &operator+=(const int64_t &micros) {this->micros += micros; return *this;};
-	inline dtime_t &operator-=(const int64_t &micros) {this->micros -= micros; return *this;};
-	inline dtime_t &operator+=(const dtime_t &other) {this->micros += other.micros; return *this;};
-
-	// special values
-	static inline dtime_t allballs() {return dtime_t(0); } // NOLINT
-};
-
-struct dtime_tz_t : public dtime_t {};
-
-//! Type used to represent timestamps (seconds,microseconds,milliseconds or nanoseconds since 1970-01-01)
-struct timestamp_t { // NOLINT
-	int64_t value;
-
-	timestamp_t() = default;
-	explicit inline timestamp_t(int64_t value_p) : value(value_p) {}
-	inline timestamp_t& operator=(int64_t value_p) {value = value_p; return *this;}
-
-	// explicit conversion
-	explicit inline operator int64_t() const {return value;}
-
-	// comparison operators
-	inline bool operator==(const timestamp_t &rhs) const {return value == rhs.value;};
-	inline bool operator!=(const timestamp_t &rhs) const {return value != rhs.value;};
-	inline bool operator<=(const timestamp_t &rhs) const {return value <= rhs.value;};
-	inline bool operator<(const timestamp_t &rhs) const {return value < rhs.value;};
-	inline bool operator>(const timestamp_t &rhs) const {return value > rhs.value;};
-	inline bool operator>=(const timestamp_t &rhs) const {return value >= rhs.value;};
-
-	// arithmetic operators
-	inline timestamp_t operator+(const double &value) const {return timestamp_t(this->value + int64_t(value));};
-	inline int64_t operator-(const timestamp_t &other) const {return this->value - other.value;};
-
-	// in-place operators
-	inline timestamp_t &operator+=(const int64_t &value) {this->value += value; return *this;};
-	inline timestamp_t &operator-=(const int64_t &value) {this->value -= value; return *this;};
-
-	// special values
-	static inline timestamp_t infinity() {return timestamp_t(std::numeric_limits<int64_t>::max()); } // NOLINT
-	static inline timestamp_t ninfinity() {return timestamp_t(-std::numeric_limits<int64_t>::max()); } // NOLINT
-	static inline timestamp_t epoch() {return timestamp_t(0); } // NOLINT
-};
-
-struct timestamp_tz_t : public timestamp_t {};
-struct timestamp_ns_t : public timestamp_t {};
-struct timestamp_ms_t : public timestamp_t {};
-struct timestamp_sec_t : public timestamp_t {};
-
-struct interval_t {
-	int32_t months;
-	int32_t days;
-	int64_t micros;
-
-	inline bool operator==(const interval_t &rhs) const {
-		return this->days == rhs.days && this->months == rhs.months && this->micros == rhs.micros;
-	}
-};
 
 struct hugeint_t {
 public:
@@ -1249,65 +1131,12 @@ struct AggregateStateType {
 	DUCKDB_API static const aggregate_state_t &GetStateType(const LogicalType &type);
 };
 
-
 DUCKDB_API string LogicalTypeIdToString(LogicalTypeId type);
 
 DUCKDB_API LogicalTypeId TransformStringToLogicalTypeId(const string &str);
 
 DUCKDB_API LogicalType TransformStringToLogicalType(const string &str);
 
-//! Returns the PhysicalType for the given type
-template <class T>
-PhysicalType GetTypeId() {
-	if (std::is_same<T, bool>()) {
-		return PhysicalType::BOOL;
-	} else if (std::is_same<T, int8_t>()) {
-		return PhysicalType::INT8;
-	} else if (std::is_same<T, int16_t>()) {
-		return PhysicalType::INT16;
-	} else if (std::is_same<T, int32_t>()) {
-		return PhysicalType::INT32;
-	} else if (std::is_same<T, int64_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, uint8_t>()) {
-		return PhysicalType::UINT8;
-	} else if (std::is_same<T, uint16_t>()) {
-		return PhysicalType::UINT16;
-	} else if (std::is_same<T, uint32_t>()) {
-		return PhysicalType::UINT32;
-	} else if (std::is_same<T, uint64_t>()) {
-		return PhysicalType::UINT64;
-	} else if (std::is_same<T, hugeint_t>()) {
-		return PhysicalType::INT128;
-	} else if (std::is_same<T, date_t>()) {
-		return PhysicalType::INT32;
-	} else if (std::is_same<T, dtime_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, timestamp_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, float>()) {
-		return PhysicalType::FLOAT;
-	} else if (std::is_same<T, double>()) {
-		return PhysicalType::DOUBLE;
-	} else if (std::is_same<T, const char *>() || std::is_same<T, char *>() || std::is_same<T, string_t>()) {
-		return PhysicalType::VARCHAR;
-	} else if (std::is_same<T, interval_t>()) {
-		return PhysicalType::INTERVAL;
-	} else {
-		return PhysicalType::INVALID;
-	}
-}
-
-template<class T>
-bool TypeIsNumber() {
-	return std::is_integral<T>() || std::is_floating_point<T>() || std::is_same<T, hugeint_t>();
-}
-
-template <class T>
-bool IsValidType() {
-	return GetTypeId<T>() != PhysicalType::INVALID;
-}
-
 //! The PhysicalType used by the row identifiers column
 extern const PhysicalType ROW_TYPE;
 
@@ -1318,11 +1147,6 @@ bool TypeIsIntegral(PhysicalType type);
 bool TypeIsNumeric(PhysicalType type);
 bool TypeIsInteger(PhysicalType type);
 
-template <class T>
-bool IsIntegerType() {
-	return TypeIsIntegral(GetTypeId<T>());
-}
-
 bool ApproxEqual(float l, float r);
 bool ApproxEqual(double l, double r);
 
@@ -1337,87 +1161,6 @@ struct aggregate_state_t {
 
 } // namespace duckdb
 
-namespace std {
-
-	//! Date
-	template <>
-	struct hash<duckdb::date_t>
-	{
-		std::size_t operator()(const duckdb::date_t& k) const
-		{
-			using std::hash;
-			return hash<int32_t>()((int32_t)k);
-		}
-	};
-
-	//! Time
-	template <>
-	struct hash<duckdb::dtime_t>
-	{
-		std::size_t operator()(const duckdb::dtime_t& k) const
-		{
-			using std::hash;
-			return hash<int64_t>()((int64_t)k);
-		}
-	};
-	template <>
-	struct hash<duckdb::dtime_tz_t>
-	{
-		std::size_t operator()(const duckdb::dtime_tz_t& k) const
-		{
-			using std::hash;
-			return hash<int64_t>()((int64_t)k);
-		}
-	};
-
-	//! Timestamp
-	template <>
-	struct hash<duckdb::timestamp_t>
-	{
-		std::size_t operator()(const duckdb::timestamp_t& k) const
-		{
-			using std::hash;
-			return hash<int64_t>()((int64_t)k);
-		}
-	};
-	template <>
-	struct hash<duckdb::timestamp_ms_t>
-	{
-		std::size_t operator()(const duckdb::timestamp_ms_t& k) const
-		{
-			using std::hash;
-			return hash<int64_t>()((int64_t)k);
-		}
-	};
-	template <>
-	struct hash<duckdb::timestamp_ns_t>
-	{
-		std::size_t operator()(const duckdb::timestamp_ns_t& k) const
-		{
-			using std::hash;
-			return hash<int64_t>()((int64_t)k);
-		}
-	};
-	template <>
-	struct hash<duckdb::timestamp_sec_t>
-	{
-		std::size_t operator()(const duckdb::timestamp_sec_t& k) const
-		{
-			using std::hash;
-			return hash<int64_t>()((int64_t)k);
-		}
-	};
-	template <>
-	struct hash<duckdb::timestamp_tz_t>
-	{
-		std::size_t operator()(const duckdb::timestamp_tz_t& k) const
-		{
-			using std::hash;
-			return hash<int64_t>()((int64_t)k);
-		}
-	};
-}
-
 
 namespace duckdb {
 
@@ -2949,82 +2692,1003 @@ public:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/timestamp.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-namespace duckdb {
 
-class CastFunctionSet;
-class Deserializer;
-class Serializer;
-struct GetCastFunctionInput;
 
-//! The Value object holds a single arbitrary value of any type that can be
-//! stored in the database.
-class Value {
-	friend struct StringValue;
-	friend struct StructValue;
-	friend struct ListValue;
-	friend struct UnionValue;
 
-public:
-	//! Create an empty NULL value of the specified type
-	DUCKDB_API explicit Value(LogicalType type = LogicalType::SQLNULL);
-	//! Create an INTEGER value
-	DUCKDB_API Value(int32_t val); // NOLINT: Allow implicit conversion from `int32_t`
-	//! Create a BIGINT value
-	DUCKDB_API Value(int64_t val); // NOLINT: Allow implicit conversion from `int64_t`
-	//! Create a FLOAT value
-	DUCKDB_API Value(float val); // NOLINT: Allow implicit conversion from `float`
-	//! Create a DOUBLE value
-	DUCKDB_API Value(double val); // NOLINT: Allow implicit conversion from `double`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(const char *val); // NOLINT: Allow implicit conversion from `const char *`
-	//! Create a NULL value
-	DUCKDB_API Value(std::nullptr_t val); // NOLINT: Allow implicit conversion from `nullptr_t`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(string_t val); // NOLINT: Allow implicit conversion from `string_t`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(string val); // NOLINT: Allow implicit conversion from `string`
-	//! Copy constructor
-	DUCKDB_API Value(const Value &other);
-	//! Move constructor
-	DUCKDB_API Value(Value &&other) noexcept;
-	//! Destructor
-	DUCKDB_API ~Value();
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/limits.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-	// copy assignment
-	DUCKDB_API Value &operator=(const Value &other);
-	// move assignment
-	DUCKDB_API Value &operator=(Value &&other) noexcept;
 
-	inline LogicalType &type() {
-		return type_;
+
+
+
+namespace duckdb {
+
+template <class T>
+struct NumericLimits {
+	DUCKDB_API static T Minimum();
+	DUCKDB_API static T Maximum();
+	DUCKDB_API static bool IsSigned();
+	DUCKDB_API static idx_t Digits();
+};
+
+template <>
+struct NumericLimits<int8_t> {
+	DUCKDB_API static int8_t Minimum();
+	DUCKDB_API static int8_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return true;
 	}
-	inline const LogicalType &type() const {
-		return type_;
+	DUCKDB_API static idx_t Digits() {
+		return 3;
 	}
-	inline bool IsNull() const {
-		return is_null;
+};
+template <>
+struct NumericLimits<int16_t> {
+	DUCKDB_API static int16_t Minimum();
+	DUCKDB_API static int16_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return true;
 	}
-
-	//! Create the lowest possible value of a given type (numeric only)
-	DUCKDB_API static Value MinimumValue(const LogicalType &type);
-	//! Create the highest possible value of a given type (numeric only)
-	DUCKDB_API static Value MaximumValue(const LogicalType &type);
-	//! Create a Numeric value of the specified type with the specified value
-	DUCKDB_API static Value Numeric(const LogicalType &type, int64_t value);
-	DUCKDB_API static Value Numeric(const LogicalType &type, hugeint_t value);
-
-	//! Create a tinyint Value from a specified value
-	DUCKDB_API static Value BOOLEAN(int8_t value);
-	//! Create a tinyint Value from a specified value
-	DUCKDB_API static Value TINYINT(int8_t value);
-	//! Create a smallint Value from a specified value
-	DUCKDB_API static Value SMALLINT(int16_t value);
-	//! Create an integer Value from a specified value
-	DUCKDB_API static Value INTEGER(int32_t value);
-	//! Create a bigint Value from a specified value
-	DUCKDB_API static Value BIGINT(int64_t value);
-	//! Create an unsigned tinyint Value from a specified value
+	DUCKDB_API static idx_t Digits() {
+		return 5;
+	}
+};
+template <>
+struct NumericLimits<int32_t> {
+	DUCKDB_API static int32_t Minimum();
+	DUCKDB_API static int32_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return true;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 10;
+	}
+};
+template <>
+struct NumericLimits<int64_t> {
+	DUCKDB_API static int64_t Minimum();
+	DUCKDB_API static int64_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return true;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 19;
+	}
+};
+template <>
+struct NumericLimits<hugeint_t> {
+	DUCKDB_API static hugeint_t Minimum();
+	DUCKDB_API static hugeint_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return true;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 39;
+	}
+};
+template <>
+struct NumericLimits<uint8_t> {
+	DUCKDB_API static uint8_t Minimum();
+	DUCKDB_API static uint8_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return false;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 3;
+	}
+};
+template <>
+struct NumericLimits<uint16_t> {
+	DUCKDB_API static uint16_t Minimum();
+	DUCKDB_API static uint16_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return false;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 5;
+	}
+};
+template <>
+struct NumericLimits<uint32_t> {
+	DUCKDB_API static uint32_t Minimum();
+	DUCKDB_API static uint32_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return false;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 10;
+	}
+};
+template <>
+struct NumericLimits<uint64_t> {
+	DUCKDB_API static uint64_t Minimum();
+	DUCKDB_API static uint64_t Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return false;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 20;
+	}
+};
+template <>
+struct NumericLimits<float> {
+	DUCKDB_API static float Minimum();
+	DUCKDB_API static float Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return true;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 127;
+	}
+};
+template <>
+struct NumericLimits<double> {
+	DUCKDB_API static double Minimum();
+	DUCKDB_API static double Maximum();
+	DUCKDB_API static bool IsSigned() {
+		return true;
+	}
+	DUCKDB_API static idx_t Digits() {
+		return 250;
+	}
+};
+
+} // namespace duckdb
+
+
+
+
+#include <functional>
+
+namespace duckdb {
+
+struct date_t;
+struct dtime_t;
+
+//! Type used to represent timestamps (seconds,microseconds,milliseconds or nanoseconds since 1970-01-01)
+struct timestamp_t { // NOLINT
+	int64_t value;
+
+	timestamp_t() = default;
+	explicit inline timestamp_t(int64_t value_p) : value(value_p) {
+	}
+	inline timestamp_t &operator=(int64_t value_p) {
+		value = value_p;
+		return *this;
+	}
+
+	// explicit conversion
+	explicit inline operator int64_t() const {
+		return value;
+	}
+
+	// comparison operators
+	inline bool operator==(const timestamp_t &rhs) const {
+		return value == rhs.value;
+	};
+	inline bool operator!=(const timestamp_t &rhs) const {
+		return value != rhs.value;
+	};
+	inline bool operator<=(const timestamp_t &rhs) const {
+		return value <= rhs.value;
+	};
+	inline bool operator<(const timestamp_t &rhs) const {
+		return value < rhs.value;
+	};
+	inline bool operator>(const timestamp_t &rhs) const {
+		return value > rhs.value;
+	};
+	inline bool operator>=(const timestamp_t &rhs) const {
+		return value >= rhs.value;
+	};
+
+	// arithmetic operators
+	inline timestamp_t operator+(const double &value) const {
+		return timestamp_t(this->value + int64_t(value));
+	};
+	inline int64_t operator-(const timestamp_t &other) const {
+		return this->value - other.value;
+	};
+
+	// in-place operators
+	inline timestamp_t &operator+=(const int64_t &value) {
+		this->value += value;
+		return *this;
+	};
+	inline timestamp_t &operator-=(const int64_t &value) {
+		this->value -= value;
+		return *this;
+	};
+
+	// special values
+	static timestamp_t infinity() {
+		return timestamp_t(NumericLimits<int64_t>::Maximum());
+	} // NOLINT
+	static timestamp_t ninfinity() {
+		return timestamp_t(-NumericLimits<int64_t>::Maximum());
+	} // NOLINT
+	static inline timestamp_t epoch() {
+		return timestamp_t(0);
+	} // NOLINT
+};
+
+struct timestamp_tz_t : public timestamp_t {};
+struct timestamp_ns_t : public timestamp_t {};
+struct timestamp_ms_t : public timestamp_t {};
+struct timestamp_sec_t : public timestamp_t {};
+
+//! The Timestamp class is a static class that holds helper functions for the Timestamp
+//! type.
+class Timestamp {
+public:
+	// min timestamp is 290308-12-22 (BC)
+	constexpr static const int32_t MIN_YEAR = -290308;
+	constexpr static const int32_t MIN_MONTH = 12;
+	constexpr static const int32_t MIN_DAY = 22;
+
+public:
+	//! Convert a string in the format "YYYY-MM-DD hh:mm:ss[.f][-+TH[:tm]]" to a timestamp object
+	DUCKDB_API static timestamp_t FromString(const string &str);
+	//! Convert a string where the offset can also be a time zone string: / [A_Za-z0-9/_]+/
+	//! If has_offset is true, then the result is an instant that was offset from UTC
+	//! If the tz is not empty, the result is still an instant, but the parts can be extracted and applied to the TZ
+	DUCKDB_API static bool TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset,
+	                                             string_t &tz);
+	DUCKDB_API static bool TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result);
+	DUCKDB_API static timestamp_t FromCString(const char *str, idx_t len);
+	//! Convert a date object to a string in the format "YYYY-MM-DD hh:mm:ss"
+	DUCKDB_API static string ToString(timestamp_t timestamp);
+
+	DUCKDB_API static date_t GetDate(timestamp_t timestamp);
+
+	DUCKDB_API static dtime_t GetTime(timestamp_t timestamp);
+	//! Create a Timestamp object from a specified (date, time) combination
+	DUCKDB_API static timestamp_t FromDatetime(date_t date, dtime_t time);
+	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_t time, timestamp_t &result);
+
+	//! Is the timestamp finite or infinite?
+	static inline bool IsFinite(timestamp_t timestamp) {
+		return timestamp != timestamp_t::infinity() && timestamp != timestamp_t::ninfinity();
+	}
+
+	//! Extract the date and time from a given timestamp object
+	DUCKDB_API static void Convert(timestamp_t date, date_t &out_date, dtime_t &out_time);
+	//! Returns current timestamp
+	DUCKDB_API static timestamp_t GetCurrentTimestamp();
+
+	//! Convert the epoch (in sec) to a timestamp
+	DUCKDB_API static timestamp_t FromEpochSeconds(int64_t ms);
+	//! Convert the epoch (in ms) to a timestamp
+	DUCKDB_API static timestamp_t FromEpochMs(int64_t ms);
+	//! Convert the epoch (in microseconds) to a timestamp
+	DUCKDB_API static timestamp_t FromEpochMicroSeconds(int64_t micros);
+	//! Convert the epoch (in nanoseconds) to a timestamp
+	DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t micros);
+
+	//! Convert the epoch (in seconds) to a timestamp
+	DUCKDB_API static int64_t GetEpochSeconds(timestamp_t timestamp);
+	//! Convert the epoch (in ms) to a timestamp
+	DUCKDB_API static int64_t GetEpochMs(timestamp_t timestamp);
+	//! Convert a timestamp to epoch (in microseconds)
+	DUCKDB_API static int64_t GetEpochMicroSeconds(timestamp_t timestamp);
+	//! Convert a timestamp to epoch (in nanoseconds)
+	DUCKDB_API static int64_t GetEpochNanoSeconds(timestamp_t timestamp);
+
+	DUCKDB_API static bool TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset,
+	                                         int &minute_offset);
+
+	DUCKDB_API static string ConversionError(const string &str);
+	DUCKDB_API static string ConversionError(string_t str);
+};
+
+} // namespace duckdb
+
+namespace std {
+
+//! Timestamp
+template <>
+struct hash<duckdb::timestamp_t> {
+	std::size_t operator()(const duckdb::timestamp_t &k) const {
+		using std::hash;
+		return hash<int64_t>()((int64_t)k);
+	}
+};
+template <>
+struct hash<duckdb::timestamp_ms_t> {
+	std::size_t operator()(const duckdb::timestamp_ms_t &k) const {
+		using std::hash;
+		return hash<int64_t>()((int64_t)k);
+	}
+};
+template <>
+struct hash<duckdb::timestamp_ns_t> {
+	std::size_t operator()(const duckdb::timestamp_ns_t &k) const {
+		using std::hash;
+		return hash<int64_t>()((int64_t)k);
+	}
+};
+template <>
+struct hash<duckdb::timestamp_sec_t> {
+	std::size_t operator()(const duckdb::timestamp_sec_t &k) const {
+		using std::hash;
+		return hash<int64_t>()((int64_t)k);
+	}
+};
+template <>
+struct hash<duckdb::timestamp_tz_t> {
+	std::size_t operator()(const duckdb::timestamp_tz_t &k) const {
+		using std::hash;
+		return hash<int64_t>()((int64_t)k);
+	}
+};
+} // namespace std
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/date.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/string_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+#include <cstring>
+
+namespace duckdb {
+
+struct string_t {
+	friend struct StringComparisonOperators;
+	friend class StringSegment;
+
+public:
+	static constexpr idx_t PREFIX_BYTES = 4 * sizeof(char);
+	static constexpr idx_t INLINE_BYTES = 12 * sizeof(char);
+	static constexpr idx_t HEADER_SIZE = sizeof(uint32_t) + PREFIX_BYTES;
+#ifndef DUCKDB_DEBUG_NO_INLINE
+	static constexpr idx_t PREFIX_LENGTH = PREFIX_BYTES;
+	static constexpr idx_t INLINE_LENGTH = INLINE_BYTES;
+#else
+	static constexpr idx_t PREFIX_LENGTH = 0;
+	static constexpr idx_t INLINE_LENGTH = 0;
+#endif
+
+	string_t() = default;
+	explicit string_t(uint32_t len) {
+		value.inlined.length = len;
+	}
+	string_t(const char *data, uint32_t len) {
+		value.inlined.length = len;
+		D_ASSERT(data || GetSize() == 0);
+		if (IsInlined()) {
+			// zero initialize the prefix first
+			// this makes sure that strings with length smaller than 4 still have an equal prefix
+			memset(value.inlined.inlined, 0, INLINE_BYTES);
+			if (GetSize() == 0) {
+				return;
+			}
+			// small string: inlined
+			memcpy(value.inlined.inlined, data, GetSize());
+		} else {
+			// large string: store pointer
+#ifndef DUCKDB_DEBUG_NO_INLINE
+			memcpy(value.pointer.prefix, data, PREFIX_LENGTH);
+#else
+			memset(value.pointer.prefix, 0, PREFIX_BYTES);
+#endif
+			value.pointer.ptr = (char *)data;
+		}
+	}
+	string_t(const char *data) : string_t(data, strlen(data)) { // NOLINT: Allow implicit conversion from `const char*`
+	}
+	string_t(const string &value)
+	    : string_t(value.c_str(), value.size()) { // NOLINT: Allow implicit conversion from `const char*`
+	}
+
+	bool IsInlined() const {
+		return GetSize() <= INLINE_LENGTH;
+	}
+
+	//! this is unsafe since the string will not be terminated at the end
+	const char *GetDataUnsafe() const {
+		return IsInlined() ? (const char *)value.inlined.inlined : value.pointer.ptr;
+	}
+
+	char *GetDataWriteable() const {
+		return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr;
+	}
+
+	const char *GetPrefix() const {
+		return value.pointer.prefix;
+	}
+
+	idx_t GetSize() const {
+		return value.inlined.length;
+	}
+
+	string GetString() const {
+		return string(GetDataUnsafe(), GetSize());
+	}
+
+	explicit operator string() const {
+		return GetString();
+	}
+
+	void Finalize() {
+		// set trailing NULL byte
+		if (GetSize() <= INLINE_LENGTH) {
+			// fill prefix with zeros if the length is smaller than the prefix length
+			for (idx_t i = GetSize(); i < INLINE_BYTES; i++) {
+				value.inlined.inlined[i] = '\0';
+			}
+		} else {
+			// copy the data into the prefix
+#ifndef DUCKDB_DEBUG_NO_INLINE
+			auto dataptr = (char *)GetDataUnsafe();
+			memcpy(value.pointer.prefix, dataptr, PREFIX_LENGTH);
+#else
+			memset(value.pointer.prefix, 0, PREFIX_BYTES);
+#endif
+		}
+	}
+
+	void Verify() const;
+	void VerifyNull() const;
+	bool operator<(const string_t &r) const {
+		auto this_str = this->GetString();
+		auto r_str = r.GetString();
+		return this_str < r_str;
+	}
+
+private:
+	union {
+		struct {
+			uint32_t length;
+			char prefix[4];
+			char *ptr;
+		} pointer;
+		struct {
+			uint32_t length;
+			char inlined[12];
+		} inlined;
+	} value;
+};
+
+} // namespace duckdb
+
+
+
+#include <functional>
+
+namespace duckdb {
+
+struct timestamp_t;
+
+//! Type used to represent dates (days since 1970-01-01)
+struct date_t { // NOLINT
+	int32_t days;
+
+	date_t() = default;
+	explicit inline date_t(int32_t days_p) : days(days_p) {
+	}
+
+	// explicit conversion
+	explicit inline operator int32_t() const {
+		return days;
+	}
+
+	// comparison operators
+	inline bool operator==(const date_t &rhs) const {
+		return days == rhs.days;
+	};
+	inline bool operator!=(const date_t &rhs) const {
+		return days != rhs.days;
+	};
+	inline bool operator<=(const date_t &rhs) const {
+		return days <= rhs.days;
+	};
+	inline bool operator<(const date_t &rhs) const {
+		return days < rhs.days;
+	};
+	inline bool operator>(const date_t &rhs) const {
+		return days > rhs.days;
+	};
+	inline bool operator>=(const date_t &rhs) const {
+		return days >= rhs.days;
+	};
+
+	// arithmetic operators
+	inline date_t operator+(const int32_t &days) const {
+		return date_t(this->days + days);
+	};
+	inline date_t operator-(const int32_t &days) const {
+		return date_t(this->days - days);
+	};
+
+	// in-place operators
+	inline date_t &operator+=(const int32_t &days) {
+		this->days += days;
+		return *this;
+	};
+	inline date_t &operator-=(const int32_t &days) {
+		this->days -= days;
+		return *this;
+	};
+
+	// special values
+	static inline date_t infinity() {
+		return date_t(NumericLimits<int32_t>::Maximum());
+	} // NOLINT
+	static inline date_t ninfinity() {
+		return date_t(-NumericLimits<int32_t>::Maximum());
+	} // NOLINT
+	static inline date_t epoch() {
+		return date_t(0);
+	} // NOLINT
+};
+
+//! The Date class is a static class that holds helper functions for the Date type.
+class Date {
+public:
+	static const char *PINF;  // NOLINT
+	static const char *NINF;  // NOLINT
+	static const char *EPOCH; // NOLINT
+
+	static const string_t MONTH_NAMES[12];
+	static const string_t MONTH_NAMES_ABBREVIATED[12];
+	static const string_t DAY_NAMES[7];
+	static const string_t DAY_NAMES_ABBREVIATED[7];
+	static const int32_t NORMAL_DAYS[13];
+	static const int32_t CUMULATIVE_DAYS[13];
+	static const int32_t LEAP_DAYS[13];
+	static const int32_t CUMULATIVE_LEAP_DAYS[13];
+	static const int32_t CUMULATIVE_YEAR_DAYS[401];
+	static const int8_t MONTH_PER_DAY_OF_YEAR[365];
+	static const int8_t LEAP_MONTH_PER_DAY_OF_YEAR[366];
+
+	// min date is 5877642-06-25 (BC) (-2^31+2)
+	constexpr static const int32_t DATE_MIN_YEAR = -5877641;
+	constexpr static const int32_t DATE_MIN_MONTH = 6;
+	constexpr static const int32_t DATE_MIN_DAY = 25;
+	// max date is 5881580-07-10 (2^31-2)
+	constexpr static const int32_t DATE_MAX_YEAR = 5881580;
+	constexpr static const int32_t DATE_MAX_MONTH = 7;
+	constexpr static const int32_t DATE_MAX_DAY = 10;
+	constexpr static const int32_t EPOCH_YEAR = 1970;
+
+	constexpr static const int32_t YEAR_INTERVAL = 400;
+	constexpr static const int32_t DAYS_PER_YEAR_INTERVAL = 146097;
+
+public:
+	//! Convert a string in the format "YYYY-MM-DD" to a date object
+	DUCKDB_API static date_t FromString(const string &str, bool strict = false);
+	//! Convert a string in the format "YYYY-MM-DD" to a date object
+	DUCKDB_API static date_t FromCString(const char *str, idx_t len, bool strict = false);
+	//! Convert a date object to a string in the format "YYYY-MM-DD"
+	DUCKDB_API static string ToString(date_t date);
+	//! Try to convert text in a buffer to a date; returns true if parsing was successful
+	//! If the date was a "special" value, the special flag will be set.
+	DUCKDB_API static bool TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool &special,
+	                                      bool strict = false);
+
+	//! Create a string "YYYY-MM-DD" from a specified (year, month, day)
+	//! combination
+	DUCKDB_API static string Format(int32_t year, int32_t month, int32_t day);
+
+	//! Extract the year, month and day from a given date object
+	DUCKDB_API static void Convert(date_t date, int32_t &out_year, int32_t &out_month, int32_t &out_day);
+	//! Create a Date object from a specified (year, month, day) combination
+	DUCKDB_API static date_t FromDate(int32_t year, int32_t month, int32_t day);
+	DUCKDB_API static bool TryFromDate(int32_t year, int32_t month, int32_t day, date_t &result);
+
+	//! Returns true if (year) is a leap year, and false otherwise
+	DUCKDB_API static bool IsLeapYear(int32_t year);
+
+	//! Returns true if the specified (year, month, day) combination is a valid
+	//! date
+	DUCKDB_API static bool IsValid(int32_t year, int32_t month, int32_t day);
+
+	//! Returns true if the specified date is finite
+	static inline bool IsFinite(date_t date) {
+		return date != date_t::infinity() && date != date_t::ninfinity();
+	}
+
+	//! The max number of days in a month of a given year
+	DUCKDB_API static int32_t MonthDays(int32_t year, int32_t month);
+
+	//! Extract the epoch from the date (seconds since 1970-01-01)
+	DUCKDB_API static int64_t Epoch(date_t date);
+	//! Extract the epoch from the date (nanoseconds since 1970-01-01)
+	DUCKDB_API static int64_t EpochNanoseconds(date_t date);
+	//! Extract the epoch from the date (microseconds since 1970-01-01)
+	DUCKDB_API static int64_t EpochMicroseconds(date_t date);
+	//! Convert the epoch (seconds since 1970-01-01) to a date_t
+	DUCKDB_API static date_t EpochToDate(int64_t epoch);
+
+	//! Extract the number of days since epoch (days since 1970-01-01)
+	DUCKDB_API static int32_t EpochDays(date_t date);
+	//! Convert the epoch number of days to a date_t
+	DUCKDB_API static date_t EpochDaysToDate(int32_t epoch);
+
+	//! Extract year of a date entry
+	DUCKDB_API static int32_t ExtractYear(date_t date);
+	//! Extract year of a date entry, but optimized to first try the last year found
+	DUCKDB_API static int32_t ExtractYear(date_t date, int32_t *last_year);
+	DUCKDB_API static int32_t ExtractYear(timestamp_t ts, int32_t *last_year);
+	//! Extract month of a date entry
+	DUCKDB_API static int32_t ExtractMonth(date_t date);
+	//! Extract day of a date entry
+	DUCKDB_API static int32_t ExtractDay(date_t date);
+	//! Extract the day of the week (1-7)
+	DUCKDB_API static int32_t ExtractISODayOfTheWeek(date_t date);
+	//! Extract the day of the year
+	DUCKDB_API static int32_t ExtractDayOfTheYear(date_t date);
+	//! Extract the ISO week number
+	//! ISO weeks start on Monday and the first week of a year
+	//! contains January 4 of that year.
+	//! In the ISO week-numbering system, it is possible for early-January dates
+	//! to be part of the 52nd or 53rd week of the previous year.
+	DUCKDB_API static void ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week);
+	DUCKDB_API static int32_t ExtractISOWeekNumber(date_t date);
+	DUCKDB_API static int32_t ExtractISOYearNumber(date_t date);
+	//! Extract the week number as Python handles it.
+	//! Either Monday or Sunday is the first day of the week,
+	//! and any date before the first Monday/Sunday returns week 0
+	//! This is a bit more consistent because week numbers in a year are always incrementing
+	DUCKDB_API static int32_t ExtractWeekNumberRegular(date_t date, bool monday_first = true);
+	//! Returns the date of the monday of the current week.
+	DUCKDB_API static date_t GetMondayOfCurrentWeek(date_t date);
+
+	//! Helper function to parse two digits from a string (e.g. "30" -> 30, "03" -> 3, "3" -> 3)
+	DUCKDB_API static bool ParseDoubleDigit(const char *buf, idx_t len, idx_t &pos, int32_t &result);
+
+	DUCKDB_API static string ConversionError(const string &str);
+	DUCKDB_API static string ConversionError(string_t str);
+
+private:
+	static void ExtractYearOffset(int32_t &n, int32_t &year, int32_t &year_offset);
+};
+
+} // namespace duckdb
+
+namespace std {
+
+//! Date
+template <>
+struct hash<duckdb::date_t> {
+	std::size_t operator()(const duckdb::date_t &k) const {
+		using std::hash;
+		return hash<int32_t>()((int32_t)k);
+	}
+};
+} // namespace std
+
+
+
+
+
+#include <functional>
+
+namespace duckdb {
+
+//! Type used to represent time (microseconds)
+struct dtime_t { // NOLINT
+	int64_t micros;
+
+	dtime_t() = default;
+	explicit inline dtime_t(int64_t micros_p) : micros(micros_p) {
+	}
+	inline dtime_t &operator=(int64_t micros_p) {
+		micros = micros_p;
+		return *this;
+	}
+
+	// explicit conversion
+	explicit inline operator int64_t() const {
+		return micros;
+	}
+	explicit inline operator double() const {
+		return micros;
+	}
+
+	// comparison operators
+	inline bool operator==(const dtime_t &rhs) const {
+		return micros == rhs.micros;
+	};
+	inline bool operator!=(const dtime_t &rhs) const {
+		return micros != rhs.micros;
+	};
+	inline bool operator<=(const dtime_t &rhs) const {
+		return micros <= rhs.micros;
+	};
+	inline bool operator<(const dtime_t &rhs) const {
+		return micros < rhs.micros;
+	};
+	inline bool operator>(const dtime_t &rhs) const {
+		return micros > rhs.micros;
+	};
+	inline bool operator>=(const dtime_t &rhs) const {
+		return micros >= rhs.micros;
+	};
+
+	// arithmetic operators
+	inline dtime_t operator+(const int64_t &micros) const {
+		return dtime_t(this->micros + micros);
+	};
+	inline dtime_t operator+(const double &micros) const {
+		return dtime_t(this->micros + int64_t(micros));
+	};
+	inline dtime_t operator-(const int64_t &micros) const {
+		return dtime_t(this->micros - micros);
+	};
+	inline dtime_t operator*(const idx_t &copies) const {
+		return dtime_t(this->micros * copies);
+	};
+	inline dtime_t operator/(const idx_t &copies) const {
+		return dtime_t(this->micros / copies);
+	};
+	inline int64_t operator-(const dtime_t &other) const {
+		return this->micros - other.micros;
+	};
+
+	// in-place operators
+	inline dtime_t &operator+=(const int64_t &micros) {
+		this->micros += micros;
+		return *this;
+	};
+	inline dtime_t &operator-=(const int64_t &micros) {
+		this->micros -= micros;
+		return *this;
+	};
+	inline dtime_t &operator+=(const dtime_t &other) {
+		this->micros += other.micros;
+		return *this;
+	};
+
+	// special values
+	static inline dtime_t allballs() {
+		return dtime_t(0);
+	} // NOLINT
+};
+
+struct dtime_tz_t : public dtime_t {};
+
+} // namespace duckdb
+
+namespace std {
+
+//! Time
+template <>
+struct hash<duckdb::dtime_t> {
+	std::size_t operator()(const duckdb::dtime_t &k) const {
+		using std::hash;
+		return hash<int64_t>()((int64_t)k);
+	}
+};
+template <>
+struct hash<duckdb::dtime_tz_t> {
+	std::size_t operator()(const duckdb::dtime_tz_t &k) const {
+		using std::hash;
+		return hash<int64_t>()((int64_t)k);
+	}
+};
+} // namespace std
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/interval.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct dtime_t;
+struct date_t;
+struct timestamp_t;
+
+struct interval_t {
+	int32_t months;
+	int32_t days;
+	int64_t micros;
+
+	inline bool operator==(const interval_t &rhs) const {
+		return this->days == rhs.days && this->months == rhs.months && this->micros == rhs.micros;
+	}
+};
+
+//! The Interval class is a static class that holds helper functions for the Interval
+//! type.
+class Interval {
+public:
+	static constexpr const int32_t MONTHS_PER_MILLENIUM = 12000;
+	static constexpr const int32_t MONTHS_PER_CENTURY = 1200;
+	static constexpr const int32_t MONTHS_PER_DECADE = 120;
+	static constexpr const int32_t MONTHS_PER_YEAR = 12;
+	static constexpr const int32_t MONTHS_PER_QUARTER = 3;
+	static constexpr const int32_t DAYS_PER_WEEK = 7;
+	//! only used for interval comparison/ordering purposes, in which case a month counts as 30 days
+	static constexpr const int64_t DAYS_PER_MONTH = 30;
+	static constexpr const int64_t DAYS_PER_YEAR = 365;
+	static constexpr const int64_t MSECS_PER_SEC = 1000;
+	static constexpr const int32_t SECS_PER_MINUTE = 60;
+	static constexpr const int32_t MINS_PER_HOUR = 60;
+	static constexpr const int32_t HOURS_PER_DAY = 24;
+	static constexpr const int32_t SECS_PER_HOUR = SECS_PER_MINUTE * MINS_PER_HOUR;
+	static constexpr const int32_t SECS_PER_DAY = SECS_PER_HOUR * HOURS_PER_DAY;
+	static constexpr const int32_t SECS_PER_WEEK = SECS_PER_DAY * DAYS_PER_WEEK;
+
+	static constexpr const int64_t MICROS_PER_MSEC = 1000;
+	static constexpr const int64_t MICROS_PER_SEC = MICROS_PER_MSEC * MSECS_PER_SEC;
+	static constexpr const int64_t MICROS_PER_MINUTE = MICROS_PER_SEC * SECS_PER_MINUTE;
+	static constexpr const int64_t MICROS_PER_HOUR = MICROS_PER_MINUTE * MINS_PER_HOUR;
+	static constexpr const int64_t MICROS_PER_DAY = MICROS_PER_HOUR * HOURS_PER_DAY;
+	static constexpr const int64_t MICROS_PER_WEEK = MICROS_PER_DAY * DAYS_PER_WEEK;
+	static constexpr const int64_t MICROS_PER_MONTH = MICROS_PER_DAY * DAYS_PER_MONTH;
+
+	static constexpr const int64_t NANOS_PER_MICRO = 1000;
+	static constexpr const int64_t NANOS_PER_MSEC = NANOS_PER_MICRO * MICROS_PER_MSEC;
+	static constexpr const int64_t NANOS_PER_SEC = NANOS_PER_MSEC * MSECS_PER_SEC;
+	static constexpr const int64_t NANOS_PER_MINUTE = NANOS_PER_SEC * SECS_PER_MINUTE;
+	static constexpr const int64_t NANOS_PER_HOUR = NANOS_PER_MINUTE * MINS_PER_HOUR;
+	static constexpr const int64_t NANOS_PER_DAY = NANOS_PER_HOUR * HOURS_PER_DAY;
+	static constexpr const int64_t NANOS_PER_WEEK = NANOS_PER_DAY * DAYS_PER_WEEK;
+
+public:
+	//! Convert a string to an interval object
+	static bool FromString(const string &str, interval_t &result);
+	//! Convert a string to an interval object
+	static bool FromCString(const char *str, idx_t len, interval_t &result, string *error_message, bool strict);
+	//! Convert an interval object to a string
+	static string ToString(const interval_t &val);
+
+	//! Convert milliseconds to a normalised interval
+	DUCKDB_API static interval_t FromMicro(int64_t micros);
+
+	//! Get Interval in milliseconds
+	static int64_t GetMilli(const interval_t &val);
+
+	//! Get Interval in microseconds
+	static int64_t GetMicro(const interval_t &val);
+
+	//! Get Interval in Nanoseconds
+	static int64_t GetNanoseconds(const interval_t &val);
+
+	//! Returns the age between two timestamps (including 30 day months)
+	static interval_t GetAge(timestamp_t timestamp_1, timestamp_t timestamp_2);
+
+	//! Returns the exact difference between two timestamps (days and seconds)
+	static interval_t GetDifference(timestamp_t timestamp_1, timestamp_t timestamp_2);
+
+	//! Returns the inverted interval
+	static interval_t Invert(interval_t interval);
+
+	//! Add an interval to a date
+	static date_t Add(date_t left, interval_t right);
+	//! Add an interval to a timestamp
+	static timestamp_t Add(timestamp_t left, interval_t right);
+	//! Add an interval to a time. In case the time overflows or underflows, modify the date by the overflow.
+	//! For example if we go from 23:00 to 02:00, we add a day to the date
+	static dtime_t Add(dtime_t left, interval_t right, date_t &date);
+
+	//! Comparison operators
+	static bool Equals(interval_t left, interval_t right);
+	static bool GreaterThan(interval_t left, interval_t right);
+	static bool GreaterThanEquals(interval_t left, interval_t right);
+};
+} // namespace duckdb
+
+
+namespace duckdb {
+
+class CastFunctionSet;
+class Deserializer;
+class Serializer;
+struct GetCastFunctionInput;
+
+//! The Value object holds a single arbitrary value of any type that can be
+//! stored in the database.
+class Value {
+	friend struct StringValue;
+	friend struct StructValue;
+	friend struct ListValue;
+	friend struct UnionValue;
+
+public:
+	//! Create an empty NULL value of the specified type
+	DUCKDB_API explicit Value(LogicalType type = LogicalType::SQLNULL);
+	//! Create an INTEGER value
+	DUCKDB_API Value(int32_t val); // NOLINT: Allow implicit conversion from `int32_t`
+	//! Create a BIGINT value
+	DUCKDB_API Value(int64_t val); // NOLINT: Allow implicit conversion from `int64_t`
+	//! Create a FLOAT value
+	DUCKDB_API Value(float val); // NOLINT: Allow implicit conversion from `float`
+	//! Create a DOUBLE value
+	DUCKDB_API Value(double val); // NOLINT: Allow implicit conversion from `double`
+	//! Create a VARCHAR value
+	DUCKDB_API Value(const char *val); // NOLINT: Allow implicit conversion from `const char *`
+	//! Create a NULL value
+	DUCKDB_API Value(std::nullptr_t val); // NOLINT: Allow implicit conversion from `nullptr_t`
+	//! Create a VARCHAR value
+	DUCKDB_API Value(string_t val); // NOLINT: Allow implicit conversion from `string_t`
+	//! Create a VARCHAR value
+	DUCKDB_API Value(string val); // NOLINT: Allow implicit conversion from `string`
+	//! Copy constructor
+	DUCKDB_API Value(const Value &other);
+	//! Move constructor
+	DUCKDB_API Value(Value &&other) noexcept;
+	//! Destructor
+	DUCKDB_API ~Value();
+
+	// copy assignment
+	DUCKDB_API Value &operator=(const Value &other);
+	// move assignment
+	DUCKDB_API Value &operator=(Value &&other) noexcept;
+
+	inline LogicalType &type() {
+		return type_;
+	}
+	inline const LogicalType &type() const {
+		return type_;
+	}
+	inline bool IsNull() const {
+		return is_null;
+	}
+
+	//! Create the lowest possible value of a given type (numeric only)
+	DUCKDB_API static Value MinimumValue(const LogicalType &type);
+	//! Create the highest possible value of a given type (numeric only)
+	DUCKDB_API static Value MaximumValue(const LogicalType &type);
+	//! Create a Numeric value of the specified type with the specified value
+	DUCKDB_API static Value Numeric(const LogicalType &type, int64_t value);
+	DUCKDB_API static Value Numeric(const LogicalType &type, hugeint_t value);
+
+	//! Create a tinyint Value from a specified value
+	DUCKDB_API static Value BOOLEAN(int8_t value);
+	//! Create a tinyint Value from a specified value
+	DUCKDB_API static Value TINYINT(int8_t value);
+	//! Create a smallint Value from a specified value
+	DUCKDB_API static Value SMALLINT(int16_t value);
+	//! Create an integer Value from a specified value
+	DUCKDB_API static Value INTEGER(int32_t value);
+	//! Create a bigint Value from a specified value
+	DUCKDB_API static Value BIGINT(int64_t value);
+	//! Create an unsigned tinyint Value from a specified value
 	DUCKDB_API static Value UTINYINT(uint8_t value);
 	//! Create an unsigned smallint Value from a specified value
 	DUCKDB_API static Value USMALLINT(uint16_t value);
@@ -3612,6 +4276,9 @@ private:
 };
 
 class Allocator {
+	// 281TB ought to be enough for anybody
+	static constexpr const idx_t MAXIMUM_ALLOC_SIZE = 281474976710656ULL;
+
 public:
 	DUCKDB_API Allocator();
 	DUCKDB_API Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p,
@@ -3722,183 +4389,48 @@ public:
 
 private:
 	//! Internal allocator that is used by the arena allocator
-	Allocator &allocator;
-	idx_t current_capacity;
-	unique_ptr<ArenaChunk> head;
-	ArenaChunk *tail;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-//! A string heap is the owner of a set of strings, strings can be inserted into
-//! it On every insert, a pointer to the inserted string is returned The
-//! returned pointer will remain valid until the StringHeap is destroyed
-class StringHeap {
-public:
-	StringHeap();
-
-	void Destroy();
-	void Move(StringHeap &other);
-
-	//! Add a string to the string heap, returns a pointer to the string
-	string_t AddString(const char *data, idx_t len);
-	//! Add a string to the string heap, returns a pointer to the string
-	string_t AddString(const char *data);
-	//! Add a string to the string heap, returns a pointer to the string
-	string_t AddString(const string &data);
-	//! Add a string to the string heap, returns a pointer to the string
-	string_t AddString(const string_t &data);
-	//! Add a blob to the string heap; blobs can be non-valid UTF8
-	string_t AddBlob(const string_t &data);
-	//! Add a blob to the string heap; blobs can be non-valid UTF8
-	string_t AddBlob(const char *data, idx_t len);
-	//! Allocates space for an empty string of size "len" on the heap
-	string_t EmptyString(idx_t len);
-
-private:
-	ArenaAllocator allocator;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/string_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-struct string_t {
-	friend struct StringComparisonOperators;
-	friend class StringSegment;
-
-public:
-	static constexpr idx_t PREFIX_BYTES = 4 * sizeof(char);
-	static constexpr idx_t INLINE_BYTES = 12 * sizeof(char);
-	static constexpr idx_t HEADER_SIZE = sizeof(uint32_t) + PREFIX_BYTES;
-#ifndef DUCKDB_DEBUG_NO_INLINE
-	static constexpr idx_t PREFIX_LENGTH = PREFIX_BYTES;
-	static constexpr idx_t INLINE_LENGTH = INLINE_BYTES;
-#else
-	static constexpr idx_t PREFIX_LENGTH = 0;
-	static constexpr idx_t INLINE_LENGTH = 0;
-#endif
-
-	string_t() = default;
-	explicit string_t(uint32_t len) {
-		value.inlined.length = len;
-	}
-	string_t(const char *data, uint32_t len) {
-		value.inlined.length = len;
-		D_ASSERT(data || GetSize() == 0);
-		if (IsInlined()) {
-			// zero initialize the prefix first
-			// this makes sure that strings with length smaller than 4 still have an equal prefix
-			memset(value.inlined.inlined, 0, INLINE_BYTES);
-			if (GetSize() == 0) {
-				return;
-			}
-			// small string: inlined
-			memcpy(value.inlined.inlined, data, GetSize());
-		} else {
-			// large string: store pointer
-#ifndef DUCKDB_DEBUG_NO_INLINE
-			memcpy(value.pointer.prefix, data, PREFIX_LENGTH);
-#else
-			memset(value.pointer.prefix, 0, PREFIX_BYTES);
-#endif
-			value.pointer.ptr = (char *)data;
-		}
-	}
-	string_t(const char *data) : string_t(data, strlen(data)) { // NOLINT: Allow implicit conversion from `const char*`
-	}
-	string_t(const string &value)
-	    : string_t(value.c_str(), value.size()) { // NOLINT: Allow implicit conversion from `const char*`
-	}
-
-	bool IsInlined() const {
-		return GetSize() <= INLINE_LENGTH;
-	}
-
-	//! this is unsafe since the string will not be terminated at the end
-	const char *GetDataUnsafe() const {
-		return IsInlined() ? (const char *)value.inlined.inlined : value.pointer.ptr;
-	}
-
-	char *GetDataWriteable() const {
-		return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr;
-	}
-
-	const char *GetPrefix() const {
-		return value.pointer.prefix;
-	}
+	Allocator &allocator;
+	idx_t current_capacity;
+	unique_ptr<ArenaChunk> head;
+	ArenaChunk *tail;
+};
 
-	idx_t GetSize() const {
-		return value.inlined.length;
-	}
+} // namespace duckdb
 
-	string GetString() const {
-		return string(GetDataUnsafe(), GetSize());
-	}
 
-	explicit operator string() const {
-		return GetString();
-	}
+namespace duckdb {
+//! A string heap is the owner of a set of strings, strings can be inserted into
+//! it On every insert, a pointer to the inserted string is returned The
+//! returned pointer will remain valid until the StringHeap is destroyed
+class StringHeap {
+public:
+	StringHeap();
 
-	void Finalize() {
-		// set trailing NULL byte
-		if (GetSize() <= INLINE_LENGTH) {
-			// fill prefix with zeros if the length is smaller than the prefix length
-			for (idx_t i = GetSize(); i < INLINE_BYTES; i++) {
-				value.inlined.inlined[i] = '\0';
-			}
-		} else {
-			// copy the data into the prefix
-#ifndef DUCKDB_DEBUG_NO_INLINE
-			auto dataptr = (char *)GetDataUnsafe();
-			memcpy(value.pointer.prefix, dataptr, PREFIX_LENGTH);
-#else
-			memset(value.pointer.prefix, 0, PREFIX_BYTES);
-#endif
-		}
-	}
+	void Destroy();
+	void Move(StringHeap &other);
 
-	void Verify() const;
-	void VerifyNull() const;
-	bool operator<(const string_t &r) const {
-		auto this_str = this->GetString();
-		auto r_str = r.GetString();
-		return this_str < r_str;
-	}
+	//! Add a string to the string heap, returns a pointer to the string
+	string_t AddString(const char *data, idx_t len);
+	//! Add a string to the string heap, returns a pointer to the string
+	string_t AddString(const char *data);
+	//! Add a string to the string heap, returns a pointer to the string
+	string_t AddString(const string &data);
+	//! Add a string to the string heap, returns a pointer to the string
+	string_t AddString(const string_t &data);
+	//! Add a blob to the string heap; blobs can be non-valid UTF8
+	string_t AddBlob(const string_t &data);
+	//! Add a blob to the string heap; blobs can be non-valid UTF8
+	string_t AddBlob(const char *data, idx_t len);
+	//! Allocates space for an empty string of size "len" on the heap
+	string_t EmptyString(idx_t len);
 
 private:
-	union {
-		struct {
-			uint32_t length;
-			char prefix[4];
-			char *ptr;
-		} pointer;
-		struct {
-			uint32_t length;
-			char inlined[12];
-		} inlined;
-	} value;
+	ArenaAllocator allocator;
 };
 
 } // namespace duckdb
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -7523,13 +8055,9 @@ struct ExpressionExecutorState {
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/limits.hpp
-//
-//
-//===----------------------------------------------------------------------===//
+
+
+
 
 
 
@@ -7537,140 +8065,68 @@ struct ExpressionExecutorState {
 
 namespace duckdb {
 
+//! Returns the PhysicalType for the given type
 template <class T>
-struct NumericLimits {
-	DUCKDB_API static T Minimum();
-	DUCKDB_API static T Maximum();
-	DUCKDB_API static bool IsSigned();
-	DUCKDB_API static idx_t Digits();
-};
-
-template <>
-struct NumericLimits<int8_t> {
-	DUCKDB_API static int8_t Minimum();
-	DUCKDB_API static int8_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return true;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 3;
-	}
-};
-template <>
-struct NumericLimits<int16_t> {
-	DUCKDB_API static int16_t Minimum();
-	DUCKDB_API static int16_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return true;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 5;
-	}
-};
-template <>
-struct NumericLimits<int32_t> {
-	DUCKDB_API static int32_t Minimum();
-	DUCKDB_API static int32_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return true;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 10;
-	}
-};
-template <>
-struct NumericLimits<int64_t> {
-	DUCKDB_API static int64_t Minimum();
-	DUCKDB_API static int64_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return true;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 19;
-	}
-};
-template <>
-struct NumericLimits<hugeint_t> {
-	DUCKDB_API static hugeint_t Minimum();
-	DUCKDB_API static hugeint_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return true;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 39;
-	}
-};
-template <>
-struct NumericLimits<uint8_t> {
-	DUCKDB_API static uint8_t Minimum();
-	DUCKDB_API static uint8_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return false;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 3;
-	}
-};
-template <>
-struct NumericLimits<uint16_t> {
-	DUCKDB_API static uint16_t Minimum();
-	DUCKDB_API static uint16_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return false;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 5;
-	}
-};
-template <>
-struct NumericLimits<uint32_t> {
-	DUCKDB_API static uint32_t Minimum();
-	DUCKDB_API static uint32_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return false;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 10;
-	}
-};
-template <>
-struct NumericLimits<uint64_t> {
-	DUCKDB_API static uint64_t Minimum();
-	DUCKDB_API static uint64_t Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return false;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 20;
-	}
-};
-template <>
-struct NumericLimits<float> {
-	DUCKDB_API static float Minimum();
-	DUCKDB_API static float Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return true;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 127;
-	}
-};
-template <>
-struct NumericLimits<double> {
-	DUCKDB_API static double Minimum();
-	DUCKDB_API static double Maximum();
-	DUCKDB_API static bool IsSigned() {
-		return true;
-	}
-	DUCKDB_API static idx_t Digits() {
-		return 250;
+PhysicalType GetTypeId() {
+	if (std::is_same<T, bool>()) {
+		return PhysicalType::BOOL;
+	} else if (std::is_same<T, int8_t>()) {
+		return PhysicalType::INT8;
+	} else if (std::is_same<T, int16_t>()) {
+		return PhysicalType::INT16;
+	} else if (std::is_same<T, int32_t>()) {
+		return PhysicalType::INT32;
+	} else if (std::is_same<T, int64_t>()) {
+		return PhysicalType::INT64;
+	} else if (std::is_same<T, uint8_t>()) {
+		return PhysicalType::UINT8;
+	} else if (std::is_same<T, uint16_t>()) {
+		return PhysicalType::UINT16;
+	} else if (std::is_same<T, uint32_t>()) {
+		return PhysicalType::UINT32;
+	} else if (std::is_same<T, uint64_t>()) {
+		return PhysicalType::UINT64;
+	} else if (std::is_same<T, hugeint_t>()) {
+		return PhysicalType::INT128;
+	} else if (std::is_same<T, date_t>()) {
+		return PhysicalType::INT32;
+	} else if (std::is_same<T, dtime_t>()) {
+		return PhysicalType::INT64;
+	} else if (std::is_same<T, timestamp_t>()) {
+		return PhysicalType::INT64;
+	} else if (std::is_same<T, float>()) {
+		return PhysicalType::FLOAT;
+	} else if (std::is_same<T, double>()) {
+		return PhysicalType::DOUBLE;
+	} else if (std::is_same<T, const char *>() || std::is_same<T, char *>() || std::is_same<T, string_t>()) {
+		return PhysicalType::VARCHAR;
+	} else if (std::is_same<T, interval_t>()) {
+		return PhysicalType::INTERVAL;
+	} else {
+		return PhysicalType::INVALID;
 	}
-};
+}
+
+template <class T>
+bool TypeIsNumber() {
+	return std::is_integral<T>() || std::is_floating_point<T>() || std::is_same<T, hugeint_t>();
+}
+
+template <class T>
+bool IsValidType() {
+	return GetTypeId<T>() != PhysicalType::INVALID;
+}
+
+template <class T>
+bool IsIntegerType() {
+	return TypeIsIntegral(GetTypeId<T>());
+}
 
 } // namespace duckdb
 
 
 
+
 namespace duckdb {
 
 //! The Hugeint class contains static operations for the INT128 type
@@ -7816,103 +8272,11 @@ template <>
 bool Hugeint::TryConvert(double value, hugeint_t &result);
 template <>
 bool Hugeint::TryConvert(long double value, hugeint_t &result);
+template <>
+bool Hugeint::TryConvert(const char *value, hugeint_t &result);
 
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/interval.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The Interval class is a static class that holds helper functions for the Interval
-//! type.
-class Interval {
-public:
-	static constexpr const int32_t MONTHS_PER_MILLENIUM = 12000;
-	static constexpr const int32_t MONTHS_PER_CENTURY = 1200;
-	static constexpr const int32_t MONTHS_PER_DECADE = 120;
-	static constexpr const int32_t MONTHS_PER_YEAR = 12;
-	static constexpr const int32_t MONTHS_PER_QUARTER = 3;
-	static constexpr const int32_t DAYS_PER_WEEK = 7;
-	//! only used for interval comparison/ordering purposes, in which case a month counts as 30 days
-	static constexpr const int64_t DAYS_PER_MONTH = 30;
-	static constexpr const int64_t DAYS_PER_YEAR = 365;
-	static constexpr const int64_t MSECS_PER_SEC = 1000;
-	static constexpr const int32_t SECS_PER_MINUTE = 60;
-	static constexpr const int32_t MINS_PER_HOUR = 60;
-	static constexpr const int32_t HOURS_PER_DAY = 24;
-	static constexpr const int32_t SECS_PER_HOUR = SECS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int32_t SECS_PER_DAY = SECS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int32_t SECS_PER_WEEK = SECS_PER_DAY * DAYS_PER_WEEK;
-
-	static constexpr const int64_t MICROS_PER_MSEC = 1000;
-	static constexpr const int64_t MICROS_PER_SEC = MICROS_PER_MSEC * MSECS_PER_SEC;
-	static constexpr const int64_t MICROS_PER_MINUTE = MICROS_PER_SEC * SECS_PER_MINUTE;
-	static constexpr const int64_t MICROS_PER_HOUR = MICROS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int64_t MICROS_PER_DAY = MICROS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int64_t MICROS_PER_WEEK = MICROS_PER_DAY * DAYS_PER_WEEK;
-	static constexpr const int64_t MICROS_PER_MONTH = MICROS_PER_DAY * DAYS_PER_MONTH;
-
-	static constexpr const int64_t NANOS_PER_MICRO = 1000;
-	static constexpr const int64_t NANOS_PER_MSEC = NANOS_PER_MICRO * MICROS_PER_MSEC;
-	static constexpr const int64_t NANOS_PER_SEC = NANOS_PER_MSEC * MSECS_PER_SEC;
-	static constexpr const int64_t NANOS_PER_MINUTE = NANOS_PER_SEC * SECS_PER_MINUTE;
-	static constexpr const int64_t NANOS_PER_HOUR = NANOS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int64_t NANOS_PER_DAY = NANOS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int64_t NANOS_PER_WEEK = NANOS_PER_DAY * DAYS_PER_WEEK;
-
-public:
-	//! Convert a string to an interval object
-	static bool FromString(const string &str, interval_t &result);
-	//! Convert a string to an interval object
-	static bool FromCString(const char *str, idx_t len, interval_t &result, string *error_message, bool strict);
-	//! Convert an interval object to a string
-	static string ToString(const interval_t &val);
-
-	//! Convert milliseconds to a normalised interval
-	DUCKDB_API static interval_t FromMicro(int64_t micros);
-
-	//! Get Interval in milliseconds
-	static int64_t GetMilli(const interval_t &val);
-
-	//! Get Interval in microseconds
-	static int64_t GetMicro(const interval_t &val);
-
-	//! Get Interval in Nanoseconds
-	static int64_t GetNanoseconds(const interval_t &val);
-
-	//! Returns the age between two timestamps (including 30 day months)
-	static interval_t GetAge(timestamp_t timestamp_1, timestamp_t timestamp_2);
-
-	//! Returns the exact difference between two timestamps (days and seconds)
-	static interval_t GetDifference(timestamp_t timestamp_1, timestamp_t timestamp_2);
-
-	//! Returns the inverted interval
-	static interval_t Invert(interval_t interval);
-
-	//! Add an interval to a date
-	static date_t Add(date_t left, interval_t right);
-	//! Add an interval to a timestamp
-	static timestamp_t Add(timestamp_t left, interval_t right);
-	//! Add an interval to a time. In case the time overflows or underflows, modify the date by the overflow.
-	//! For example if we go from 23:00 to 02:00, we add a day to the date
-	static dtime_t Add(dtime_t left, interval_t right, date_t &date);
-
-	//! Comparison operators
-	static bool Equals(interval_t left, interval_t right);
-	static bool GreaterThan(interval_t left, interval_t right);
-	static bool GreaterThanEquals(interval_t left, interval_t right);
-};
-} // namespace duckdb
 
 
 
@@ -8807,6 +9171,7 @@ public:
 
 public:
 	virtual unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info);
+	virtual void UndoAlter(ClientContext &context, AlterInfo *info);
 
 	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context);
 
@@ -10798,6 +11163,8 @@ public:
 public:
 	bool HasGeneratedColumns() const;
 	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
+	void UndoAlter(ClientContext &context, AlterInfo *info) override;
+
 	//! Returns whether or not a column with the given name exists
 	DUCKDB_API bool ColumnExists(const string &name);
 	//! Returns a reference to the column of the specified name. Throws an
@@ -10976,6 +11343,9 @@ public:
 		return true;
 	}
 
+	//! Returns the set of table indexes of this operator
+	virtual vector<idx_t> GetTableIndex() const;
+
 protected:
 	//! Resolve types for this specific operator
 	virtual void ResolveTypes() = 0;
@@ -13826,6 +14196,9 @@ public:
 	void Reset();
 	void ResetSink();
 	void ResetSource(bool force);
+	void ClearSource() {
+		source_state.reset();
+	}
 	void Schedule(shared_ptr<Event> &event);
 
 	//! Finalize this pipeline
@@ -17399,6 +17772,7 @@ public:
 namespace duckdb {
 
 struct string_t;
+struct interval_t;
 
 // efficient hash function that maximizes the avalanche effect and minimizes
 // bias
@@ -21077,163 +21451,24 @@ DUCKDB_API void duckdb_finish_execution(duckdb_task_state state);
 /*!
 Check if the provided duckdb_task_state has finished execution
 
-* state: The task state to inspect
-* returns: Whether or not duckdb_finish_execution has been called on the task state
-*/
-DUCKDB_API bool duckdb_task_state_is_finished(duckdb_task_state state);
-
-/*!
-Destroys the task state returned from duckdb_create_task_state.
-
-Note that this should not be called while there is an active duckdb_execute_tasks_state running
-on the task state.
-
-* state: The task state to clean up
-*/
-DUCKDB_API void duckdb_destroy_task_state(duckdb_task_state state);
-
-#ifdef __cplusplus
-}
-#endif
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/date.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The Date class is a static class that holds helper functions for the Date type.
-class Date {
-public:
-	static const char *PINF;  // NOLINT
-	static const char *NINF;  // NOLINT
-	static const char *EPOCH; // NOLINT
-
-	static const string_t MONTH_NAMES[12];
-	static const string_t MONTH_NAMES_ABBREVIATED[12];
-	static const string_t DAY_NAMES[7];
-	static const string_t DAY_NAMES_ABBREVIATED[7];
-	static const int32_t NORMAL_DAYS[13];
-	static const int32_t CUMULATIVE_DAYS[13];
-	static const int32_t LEAP_DAYS[13];
-	static const int32_t CUMULATIVE_LEAP_DAYS[13];
-	static const int32_t CUMULATIVE_YEAR_DAYS[401];
-	static const int8_t MONTH_PER_DAY_OF_YEAR[365];
-	static const int8_t LEAP_MONTH_PER_DAY_OF_YEAR[366];
-
-	// min date is 5877642-06-25 (BC) (-2^31+2)
-	constexpr static const int32_t DATE_MIN_YEAR = -5877641;
-	constexpr static const int32_t DATE_MIN_MONTH = 6;
-	constexpr static const int32_t DATE_MIN_DAY = 25;
-	// max date is 5881580-07-10 (2^31-2)
-	constexpr static const int32_t DATE_MAX_YEAR = 5881580;
-	constexpr static const int32_t DATE_MAX_MONTH = 7;
-	constexpr static const int32_t DATE_MAX_DAY = 10;
-	constexpr static const int32_t EPOCH_YEAR = 1970;
-
-	constexpr static const int32_t YEAR_INTERVAL = 400;
-	constexpr static const int32_t DAYS_PER_YEAR_INTERVAL = 146097;
-
-public:
-	//! Convert a string in the format "YYYY-MM-DD" to a date object
-	DUCKDB_API static date_t FromString(const string &str, bool strict = false);
-	//! Convert a string in the format "YYYY-MM-DD" to a date object
-	DUCKDB_API static date_t FromCString(const char *str, idx_t len, bool strict = false);
-	//! Convert a date object to a string in the format "YYYY-MM-DD"
-	DUCKDB_API static string ToString(date_t date);
-	//! Try to convert text in a buffer to a date; returns true if parsing was successful
-	//! If the date was a "special" value, the special flag will be set.
-	DUCKDB_API static bool TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool &special,
-	                                      bool strict = false);
-
-	//! Create a string "YYYY-MM-DD" from a specified (year, month, day)
-	//! combination
-	DUCKDB_API static string Format(int32_t year, int32_t month, int32_t day);
-
-	//! Extract the year, month and day from a given date object
-	DUCKDB_API static void Convert(date_t date, int32_t &out_year, int32_t &out_month, int32_t &out_day);
-	//! Create a Date object from a specified (year, month, day) combination
-	DUCKDB_API static date_t FromDate(int32_t year, int32_t month, int32_t day);
-	DUCKDB_API static bool TryFromDate(int32_t year, int32_t month, int32_t day, date_t &result);
-
-	//! Returns true if (year) is a leap year, and false otherwise
-	DUCKDB_API static bool IsLeapYear(int32_t year);
-
-	//! Returns true if the specified (year, month, day) combination is a valid
-	//! date
-	DUCKDB_API static bool IsValid(int32_t year, int32_t month, int32_t day);
-
-	//! Returns true if the specified date is finite
-	static inline bool IsFinite(date_t date) {
-		return date != date_t::infinity() && date != date_t::ninfinity();
-	}
-
-	//! The max number of days in a month of a given year
-	DUCKDB_API static int32_t MonthDays(int32_t year, int32_t month);
-
-	//! Extract the epoch from the date (seconds since 1970-01-01)
-	DUCKDB_API static int64_t Epoch(date_t date);
-	//! Extract the epoch from the date (nanoseconds since 1970-01-01)
-	DUCKDB_API static int64_t EpochNanoseconds(date_t date);
-	//! Extract the epoch from the date (microseconds since 1970-01-01)
-	DUCKDB_API static int64_t EpochMicroseconds(date_t date);
-	//! Convert the epoch (seconds since 1970-01-01) to a date_t
-	DUCKDB_API static date_t EpochToDate(int64_t epoch);
-
-	//! Extract the number of days since epoch (days since 1970-01-01)
-	DUCKDB_API static int32_t EpochDays(date_t date);
-	//! Convert the epoch number of days to a date_t
-	DUCKDB_API static date_t EpochDaysToDate(int32_t epoch);
-
-	//! Extract year of a date entry
-	DUCKDB_API static int32_t ExtractYear(date_t date);
-	//! Extract year of a date entry, but optimized to first try the last year found
-	DUCKDB_API static int32_t ExtractYear(date_t date, int32_t *last_year);
-	DUCKDB_API static int32_t ExtractYear(timestamp_t ts, int32_t *last_year);
-	//! Extract month of a date entry
-	DUCKDB_API static int32_t ExtractMonth(date_t date);
-	//! Extract day of a date entry
-	DUCKDB_API static int32_t ExtractDay(date_t date);
-	//! Extract the day of the week (1-7)
-	DUCKDB_API static int32_t ExtractISODayOfTheWeek(date_t date);
-	//! Extract the day of the year
-	DUCKDB_API static int32_t ExtractDayOfTheYear(date_t date);
-	//! Extract the ISO week number
-	//! ISO weeks start on Monday and the first week of a year
-	//! contains January 4 of that year.
-	//! In the ISO week-numbering system, it is possible for early-January dates
-	//! to be part of the 52nd or 53rd week of the previous year.
-	DUCKDB_API static void ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week);
-	DUCKDB_API static int32_t ExtractISOWeekNumber(date_t date);
-	DUCKDB_API static int32_t ExtractISOYearNumber(date_t date);
-	//! Extract the week number as Python handles it.
-	//! Either Monday or Sunday is the first day of the week,
-	//! and any date before the first Monday/Sunday returns week 0
-	//! This is a bit more consistent because week numbers in a year are always incrementing
-	DUCKDB_API static int32_t ExtractWeekNumberRegular(date_t date, bool monday_first = true);
-	//! Returns the date of the monday of the current week.
-	DUCKDB_API static date_t GetMondayOfCurrentWeek(date_t date);
-
-	//! Helper function to parse two digits from a string (e.g. "30" -> 30, "03" -> 3, "3" -> 3)
-	DUCKDB_API static bool ParseDoubleDigit(const char *buf, idx_t len, idx_t &pos, int32_t &result);
+* state: The task state to inspect
+* returns: Whether or not duckdb_finish_execution has been called on the task state
+*/
+DUCKDB_API bool duckdb_task_state_is_finished(duckdb_task_state state);
 
-	DUCKDB_API static string ConversionError(const string &str);
-	DUCKDB_API static string ConversionError(string_t str);
+/*!
+Destroys the task state returned from duckdb_create_task_state.
 
-private:
-	static void ExtractYearOffset(int32_t &n, int32_t &year, int32_t &year_offset);
-};
-} // namespace duckdb
+Note that this should not be called while there is an active duckdb_execute_tasks_state running
+on the task state.
+
+* state: The task state to clean up
+*/
+DUCKDB_API void duckdb_destroy_task_state(duckdb_task_state state);
+
+#ifdef __cplusplus
+}
+#endif
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -21416,86 +21651,6 @@ public:
 	}
 };
 
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/timestamp.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The Timestamp class is a static class that holds helper functions for the Timestamp
-//! type.
-class Timestamp {
-public:
-	// min timestamp is 290308-12-22 (BC)
-	constexpr static const int32_t MIN_YEAR = -290308;
-	constexpr static const int32_t MIN_MONTH = 12;
-	constexpr static const int32_t MIN_DAY = 22;
-
-public:
-	//! Convert a string in the format "YYYY-MM-DD hh:mm:ss[.f][-+TH[:tm]]" to a timestamp object
-	DUCKDB_API static timestamp_t FromString(const string &str);
-	//! Convert a string where the offset can also be a time zone string: / [A_Za-z0-9/_]+/
-	//! If has_offset is true, then the result is an instant that was offset from UTC
-	//! If the tz is not empty, the result is still an instant, but the parts can be extracted and applied to the TZ
-	DUCKDB_API static bool TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset,
-	                                             string_t &tz);
-	DUCKDB_API static bool TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result);
-	DUCKDB_API static timestamp_t FromCString(const char *str, idx_t len);
-	//! Convert a date object to a string in the format "YYYY-MM-DD hh:mm:ss"
-	DUCKDB_API static string ToString(timestamp_t timestamp);
-
-	DUCKDB_API static date_t GetDate(timestamp_t timestamp);
-
-	DUCKDB_API static dtime_t GetTime(timestamp_t timestamp);
-	//! Create a Timestamp object from a specified (date, time) combination
-	DUCKDB_API static timestamp_t FromDatetime(date_t date, dtime_t time);
-	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_t time, timestamp_t &result);
-
-	//! Is the timestamp finite or infinite?
-	static inline bool IsFinite(timestamp_t timestamp) {
-		return timestamp != timestamp_t::infinity() && timestamp != timestamp_t::ninfinity();
-	}
-
-	//! Extract the date and time from a given timestamp object
-	DUCKDB_API static void Convert(timestamp_t date, date_t &out_date, dtime_t &out_time);
-	//! Returns current timestamp
-	DUCKDB_API static timestamp_t GetCurrentTimestamp();
-
-	//! Convert the epoch (in sec) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochSeconds(int64_t ms);
-	//! Convert the epoch (in ms) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochMs(int64_t ms);
-	//! Convert the epoch (in microseconds) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochMicroSeconds(int64_t micros);
-	//! Convert the epoch (in nanoseconds) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t micros);
-
-	//! Convert the epoch (in seconds) to a timestamp
-	DUCKDB_API static int64_t GetEpochSeconds(timestamp_t timestamp);
-	//! Convert the epoch (in ms) to a timestamp
-	DUCKDB_API static int64_t GetEpochMs(timestamp_t timestamp);
-	//! Convert a timestamp to epoch (in microseconds)
-	DUCKDB_API static int64_t GetEpochMicroSeconds(timestamp_t timestamp);
-	//! Convert a timestamp to epoch (in nanoseconds)
-	DUCKDB_API static int64_t GetEpochNanoSeconds(timestamp_t timestamp);
-
-	DUCKDB_API static bool TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset,
-	                                         int &minute_offset);
-
-	DUCKDB_API static string ConversionError(const string &str);
-	DUCKDB_API static string ConversionError(string_t str);
-};
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -21513,6 +21668,8 @@ public:
 
 namespace duckdb {
 
+struct dtime_t;
+
 //! The Time class is a static class that holds helper functions for the Time
 //! type.
 class Time {
@@ -21563,6 +21720,11 @@ class DuckDB;
 class TableCatalogEntry;
 class Connection;
 
+enum class AppenderType : uint8_t {
+	LOGICAL, // Cast input -> LogicalType
+	PHYSICAL // Cast input -> PhysicalType
+};
+
 //! The Appender class can be used to append elements to a table.
 class BaseAppender {
 protected:
@@ -21578,10 +21740,14 @@ protected:
 	DataChunk chunk;
 	//! The current column to append to
 	idx_t column = 0;
+	//! The type of the appender
+	AppenderType appender_type;
+
+protected:
+	DUCKDB_API BaseAppender(Allocator &allocator, AppenderType type);
+	DUCKDB_API BaseAppender(Allocator &allocator, vector<LogicalType> types, AppenderType type);
 
 public:
-	DUCKDB_API BaseAppender(Allocator &allocator);
-	DUCKDB_API BaseAppender(Allocator &allocator, vector<LogicalType> types);
 	DUCKDB_API virtual ~BaseAppender();
 
 	//! Begins a new row append, after calling this the other AppendX() functions
@@ -21629,6 +21795,8 @@ protected:
 	void AppendValueInternal(T value);
 	template <class SRC, class DST>
 	void AppendValueInternal(Vector &vector, SRC input);
+	template <class SRC, class DST>
+	void AppendDecimalValueInternal(Vector &vector, SRC input);
 
 	void AppendRowRecursive() {
 		EndRow();
@@ -30618,6 +30786,7 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	vector<idx_t> GetTableIndex() const override;
 
 protected:
 	void ResolveTypes() override;
@@ -30743,10 +30912,12 @@ public:
 	}
 };
 } // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/positional_reference_expression.hpp
+// duckdb/parser/expression/case_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30755,32 +30926,97 @@ public:
 
 
 
+
 namespace duckdb {
-class PositionalReferenceExpression : public ParsedExpression {
+
+struct CaseCheck {
+	unique_ptr<ParsedExpression> when_expr;
+	unique_ptr<ParsedExpression> then_expr;
+};
+
+//! The CaseExpression represents a CASE expression in the query
+class CaseExpression : public ParsedExpression {
 public:
-	DUCKDB_API PositionalReferenceExpression(idx_t index);
+	DUCKDB_API CaseExpression();
 
-	idx_t index;
+	vector<CaseCheck> case_checks;
+	unique_ptr<ParsedExpression> else_expr;
 
 public:
-	bool IsScalar() const override {
-		return false;
+	string ToString() const override;
+
+	static bool Equals(const CaseExpression *a, const CaseExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		string case_str = "CASE ";
+		for (auto &check : entry.case_checks) {
+			case_str += " WHEN (" + check.when_expr->ToString() + ")";
+			case_str += " THEN (" + check.then_expr->ToString() + ")";
+		}
+		case_str += " ELSE " + entry.else_expr->ToString();
+		case_str += " END";
+		return case_str;
 	}
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/cast_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! CastExpression represents a type cast from one SQL type to another SQL type
+class CastExpression : public ParsedExpression {
+public:
+	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
+
+	//! The child of the cast expression
+	unique_ptr<ParsedExpression> child;
+	//! The type to cast to
+	LogicalType cast_type;
+	//! Whether or not this is a try_cast expression
+	bool try_cast;
 
+public:
 	string ToString() const override;
 
-	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
+	static bool Equals(const CastExpression *a, const CastExpression *b);
+
 	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
+		       entry.cast_type.ToString() + ")";
+	}
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/case_expression.hpp
+// duckdb/parser/expression/collate_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30789,26 +31025,58 @@ public:
 
 
 
-
 namespace duckdb {
 
-struct CaseCheck {
-	unique_ptr<ParsedExpression> when_expr;
-	unique_ptr<ParsedExpression> then_expr;
+//! CollateExpression represents a COLLATE statement
+class CollateExpression : public ParsedExpression {
+public:
+	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
+
+	//! The child of the cast expression
+	unique_ptr<ParsedExpression> child;
+	//! The collation clause
+	string collation;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
+} // namespace duckdb
 
-//! The CaseExpression represents a CASE expression in the query
-class CaseExpression : public ParsedExpression {
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/comparison_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
+//! and has two children.
+class ComparisonExpression : public ParsedExpression {
 public:
-	DUCKDB_API CaseExpression();
+	DUCKDB_API ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
+	                                unique_ptr<ParsedExpression> right);
 
-	vector<CaseCheck> case_checks;
-	unique_ptr<ParsedExpression> else_expr;
+	unique_ptr<ParsedExpression> left;
+	unique_ptr<ParsedExpression> right;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const CaseExpression *a, const CaseExpression *b);
+	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -30817,22 +31085,17 @@ public:
 
 public:
 	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string case_str = "CASE ";
-		for (auto &check : entry.case_checks) {
-			case_str += " WHEN (" + check.when_expr->ToString() + ")";
-			case_str += " THEN (" + check.then_expr->ToString() + ")";
-		}
-		case_str += " ELSE " + entry.else_expr->ToString();
-		case_str += " END";
-		return case_str;
+	static string ToString(const T &entry) {
+		return StringUtil::Format("(%s %s %s)", entry.left->ToString(), ExpressionTypeToOperator(entry.type),
+		                          entry.right->ToString());
 	}
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/comparison_expression.hpp
+// duckdb/parser/expression/conjunction_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30841,21 +31104,25 @@ public:
 
 
 
+
 namespace duckdb {
-//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
-//! and has two children.
-class ComparisonExpression : public ParsedExpression {
+
+//! Represents a conjunction (AND/OR)
+class ConjunctionExpression : public ParsedExpression {
 public:
-	DUCKDB_API ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                unique_ptr<ParsedExpression> right);
+	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
+	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
+	                                 unique_ptr<ParsedExpression> right);
 
-	unique_ptr<ParsedExpression> left;
-	unique_ptr<ParsedExpression> right;
+	vector<unique_ptr<ParsedExpression>> children;
 
 public:
+	void AddExpression(unique_ptr<ParsedExpression> expr);
+
 	string ToString() const override;
 
-	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
+	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -30865,11 +31132,15 @@ public:
 public:
 	template <class T, class BASE>
 	static string ToString(const T &entry) {
-		return StringUtil::Format("(%s %s %s)", entry.left->ToString(), ExpressionTypeToOperator(entry.type),
-		                          entry.right->ToString());
+		string result = "(" + entry.children[0]->ToString();
+		for (idx_t i = 1; i < entry.children.size(); i++) {
+			result += " " + ExpressionTypeToOperator(entry.type) + " " + entry.children[i]->ToString();
+		}
+		return result + ")";
 	}
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -30906,10 +31177,11 @@ public:
 };
 
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/star_expression.hpp
+// duckdb/parser/expression/default_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30918,29 +31190,18 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! Represents a * expression in the SELECT clause
-class StarExpression : public ParsedExpression {
+//! Represents the default value of a column
+class DefaultExpression : public ParsedExpression {
 public:
-	StarExpression(string relation_name = string());
-
-	//! The relation name in case of tbl.*, or empty if this is a normal *
-	string relation_name;
-	//! List of columns to exclude from the STAR expression
-	case_insensitive_set_t exclude_list;
-	//! List of columns to replace with another expression
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
-	//! Regular expression to select columns (if any)
-	string regex;
-	//! Whether or not this is a COLUMNS expression
-	bool columns = false;
+	DefaultExpression();
 
 public:
-	string ToString() const override;
+	bool IsScalar() const override {
+		return false;
+	}
 
-	static bool Equals(const StarExpression *a, const StarExpression *b);
+	string ToString() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -30948,10 +31209,11 @@ public:
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/default_expression.hpp
+// duckdb/parser/expression/function_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30960,25 +31222,113 @@ public:
 
 
 
+
+
 namespace duckdb {
-//! Represents the default value of a column
-class DefaultExpression : public ParsedExpression {
+//! Represents a function call
+class FunctionExpression : public ParsedExpression {
 public:
-	DefaultExpression();
+	DUCKDB_API FunctionExpression(string schema_name, const string &function_name,
+	                              vector<unique_ptr<ParsedExpression>> children,
+	                              unique_ptr<ParsedExpression> filter = nullptr,
+	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
+	                              bool is_operator = false, bool export_state = false);
+	DUCKDB_API FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
+	                              unique_ptr<ParsedExpression> filter = nullptr,
+	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
+	                              bool is_operator = false, bool export_state = false);
 
-public:
-	bool IsScalar() const override {
-		return false;
-	}
+	//! Schema of the function
+	string schema;
+	//! Function name
+	string function_name;
+	//! Whether or not the function is an operator, only used for rendering
+	bool is_operator;
+	//! List of arguments to the function
+	vector<unique_ptr<ParsedExpression>> children;
+	//! Whether or not the aggregate function is distinct, only used for aggregates
+	bool distinct;
+	//! Expression representing a filter, only used for aggregates
+	unique_ptr<ParsedExpression> filter;
+	//! Modifier representing an ORDER BY, only used for aggregates
+	unique_ptr<OrderModifier> order_bys;
+	//! whether this function should export its state or not
+	bool export_state;
 
+public:
 	string ToString() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
+	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
+	hash_t Hash() const override;
+
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+	void Verify() const override;
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
+	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
+	                       bool export_state = false, bool add_alias = false) {
+		if (is_operator) {
+			// built-in operator
+			D_ASSERT(!distinct);
+			if (entry.children.size() == 1) {
+				if (StringUtil::Contains(function_name, "__postfix")) {
+					return "(" + entry.children[0]->ToString() + ")" +
+					       StringUtil::Replace(function_name, "__postfix", "");
+				} else {
+					return function_name + "(" + entry.children[0]->ToString() + ")";
+				}
+			} else if (entry.children.size() == 2) {
+				return StringUtil::Format("(%s %s %s)", entry.children[0]->ToString(), function_name,
+				                          entry.children[1]->ToString());
+			}
+		}
+		// standard function call
+		string result = schema.empty() ? function_name : schema + "." + function_name;
+		result += "(";
+		if (distinct) {
+			result += "DISTINCT ";
+		}
+		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
+			return child->alias.empty() || !add_alias
+			           ? child->ToString()
+			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
+		});
+		// ordered aggregate
+		if (order_bys && !order_bys->orders.empty()) {
+			if (entry.children.empty()) {
+				result += ") WITHIN GROUP (";
+			}
+			result += " ORDER BY ";
+			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
+				if (i > 0) {
+					result += ", ";
+				}
+				result += order_bys->orders[i].ToString();
+			}
+		}
+		result += ")";
+
+		// filtered aggregate
+		if (filter) {
+			result += " FILTER (WHERE " + filter->ToString() + ")";
+		}
+
+		if (export_state) {
+			result += " EXPORT_STATE";
+		}
+
+		return result;
+	}
 };
 } // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -31082,104 +31432,18 @@ public:
 			result += "])";
 			return result;
 		}
-		default:
-			throw InternalException("Unrecognized operator type");
-		}
-	}
-};
-
-} // namespace duckdb
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/cast_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! CastExpression represents a type cast from one SQL type to another SQL type
-class CastExpression : public ParsedExpression {
-public:
-	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
-
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The type to cast to
-	LogicalType cast_type;
-	//! Whether or not this is a try_cast expression
-	bool try_cast;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const CastExpression *a, const CastExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
-		       entry.cast_type.ToString() + ")";
-	}
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/collate_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! CollateExpression represents a COLLATE statement
-class CollateExpression : public ParsedExpression {
-public:
-	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
-
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The collation clause
-	string collation;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const CollateExpression *a, const CollateExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+		default:
+			throw InternalException("Unrecognized operator type");
+		}
+	}
 };
-} // namespace duckdb
-
 
+} // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/conjunction_expression.hpp
+// duckdb/parser/expression/parameter_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31188,49 +31452,37 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! Represents a conjunction (AND/OR)
-class ConjunctionExpression : public ParsedExpression {
+class ParameterExpression : public ParsedExpression {
 public:
-	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                 unique_ptr<ParsedExpression> right);
+	ParameterExpression();
 
-	vector<unique_ptr<ParsedExpression>> children;
+	idx_t parameter_nr;
 
 public:
-	void AddExpression(unique_ptr<ParsedExpression> expr);
+	bool IsScalar() const override {
+		return true;
+	}
+	bool HasParameter() const override {
+		return true;
+	}
 
 	string ToString() const override;
 
-	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
+	static bool Equals(const ParameterExpression *a, const ParameterExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
+	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string result = "(" + entry.children[0]->ToString();
-		for (idx_t i = 1; i < entry.children.size(); i++) {
-			result += " " + ExpressionTypeToOperator(entry.type) + " " + entry.children[i]->ToString();
-		}
-		return result + ")";
-	}
 };
 } // namespace duckdb
 
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/function_expression.hpp
+// duckdb/parser/expression/positional_reference_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31239,118 +31491,33 @@ public:
 
 
 
-
-
 namespace duckdb {
-//! Represents a function call
-class FunctionExpression : public ParsedExpression {
+class PositionalReferenceExpression : public ParsedExpression {
 public:
-	DUCKDB_API FunctionExpression(string schema_name, const string &function_name,
-	                              vector<unique_ptr<ParsedExpression>> children,
-	                              unique_ptr<ParsedExpression> filter = nullptr,
-	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
-	                              bool is_operator = false, bool export_state = false);
-	DUCKDB_API FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                              unique_ptr<ParsedExpression> filter = nullptr,
-	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
-	                              bool is_operator = false, bool export_state = false);
+	DUCKDB_API PositionalReferenceExpression(idx_t index);
 
-	//! Schema of the function
-	string schema;
-	//! Function name
-	string function_name;
-	//! Whether or not the function is an operator, only used for rendering
-	bool is_operator;
-	//! List of arguments to the function
-	vector<unique_ptr<ParsedExpression>> children;
-	//! Whether or not the aggregate function is distinct, only used for aggregates
-	bool distinct;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<ParsedExpression> filter;
-	//! Modifier representing an ORDER BY, only used for aggregates
-	unique_ptr<OrderModifier> order_bys;
-	//! whether this function should export its state or not
-	bool export_state;
+	idx_t index;
 
 public:
+	bool IsScalar() const override {
+		return false;
+	}
+
 	string ToString() const override;
 
+	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
 	unique_ptr<ParsedExpression> Copy() const override;
-
-	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
 	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-	void Verify() const override;
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
-	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
-	                       bool export_state = false, bool add_alias = false) {
-		if (is_operator) {
-			// built-in operator
-			D_ASSERT(!distinct);
-			if (entry.children.size() == 1) {
-				if (StringUtil::Contains(function_name, "__postfix")) {
-					return "(" + entry.children[0]->ToString() + ")" +
-					       StringUtil::Replace(function_name, "__postfix", "");
-				} else {
-					return function_name + "(" + entry.children[0]->ToString() + ")";
-				}
-			} else if (entry.children.size() == 2) {
-				return StringUtil::Format("(%s %s %s)", entry.children[0]->ToString(), function_name,
-				                          entry.children[1]->ToString());
-			}
-		}
-		// standard function call
-		string result = schema.empty() ? function_name : schema + "." + function_name;
-		result += "(";
-		if (distinct) {
-			result += "DISTINCT ";
-		}
-		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
-			return child->alias.empty() || !add_alias
-			           ? child->ToString()
-			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
-		});
-		// ordered aggregate
-		if (order_bys && !order_bys->orders.empty()) {
-			if (entry.children.empty()) {
-				result += ") WITHIN GROUP (";
-			}
-			result += " ORDER BY ";
-			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
-				if (i > 0) {
-					result += ", ";
-				}
-				result += order_bys->orders[i].ToString();
-			}
-		}
-		result += ")";
-
-		// filtered aggregate
-		if (filter) {
-			result += " FILTER (WHERE " + filter->ToString() + ")";
-		}
-
-		if (export_state) {
-			result += " EXPORT_STATE";
-		}
-
-		return result;
-	}
 };
 } // namespace duckdb
 
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/parameter_expression.hpp
+// duckdb/parser/expression/star_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31359,35 +31526,37 @@ public:
 
 
 
+
 namespace duckdb {
-class ParameterExpression : public ParsedExpression {
+
+//! Represents a * expression in the SELECT clause
+class StarExpression : public ParsedExpression {
 public:
-	ParameterExpression();
+	StarExpression(string relation_name = string());
 
-	idx_t parameter_nr;
+	//! The relation name in case of tbl.*, or empty if this is a normal *
+	string relation_name;
+	//! List of columns to exclude from the STAR expression
+	case_insensitive_set_t exclude_list;
+	//! List of columns to replace with another expression
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
+	//! Regular expression to select columns (if any)
+	string regex;
+	//! Whether or not this is a COLUMNS expression
+	bool columns = false;
 
 public:
-	bool IsScalar() const override {
-		return true;
-	}
-	bool HasParameter() const override {
-		return true;
-	}
-
 	string ToString() const override;
 
-	static bool Equals(const ParameterExpression *a, const ParameterExpression *b);
+	static bool Equals(const StarExpression *a, const StarExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
 
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -31442,7 +31611,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_type_info.hpp
+// duckdb/parser/parsed_data/create_view_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31452,40 +31621,104 @@ public:
 
 
 
+namespace duckdb {
 
+struct CreateViewInfo : public CreateInfo {
+	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
+	}
+	CreateViewInfo(string schema, string view_name)
+	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
+	}
 
-namespace duckdb {
+	//! Table name to insert to
+	string view_name;
+	//! Aliases of the view
+	vector<string> aliases;
+	//! Return types
+	vector<LogicalType> types;
+	//! The SelectStatement of the view
+	unique_ptr<SelectStatement> query;
 
-struct CreateTypeInfo : public CreateInfo {
-	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateViewInfo>(schema, view_name);
+		CopyProperties(*result);
+		result->aliases = aliases;
+		result->types = types;
+		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+		return move(result);
 	}
-	CreateTypeInfo(string name_p, LogicalType type_p)
-	    : CreateInfo(CatalogType::TYPE_ENTRY), name(move(name_p)), type(move(type_p)) {
+
+	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &deserializer) {
+		auto result = make_unique<CreateViewInfo>();
+		result->DeserializeBase(deserializer);
+
+		FieldReader reader(deserializer);
+		result->view_name = reader.ReadRequired<string>();
+		result->aliases = reader.ReadRequiredList<string>();
+		result->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+		result->query = reader.ReadOptional<SelectStatement>(nullptr);
+		reader.Finalize();
+
+		return result;
+	}
+
+protected:
+	void SerializeInternal(Serializer &serializer) const override {
+		FieldWriter writer(serializer);
+		writer.WriteString(view_name);
+		writer.WriteList<string>(aliases);
+		writer.WriteRegularSerializableList(types);
+		writer.WriteOptional(query);
+		writer.Finalize();
 	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/alter_function_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Alter Table
+//===--------------------------------------------------------------------===//
+enum class AlterFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
+
+struct AlterFunctionInfo : public AlterInfo {
+	AlterFunctionInfo(AlterFunctionType type, string schema, string name, bool if_exists);
+	virtual ~AlterFunctionInfo() override;
 
-	//! Name of the Type
-	string name;
-	//! Logical Type
-	LogicalType type;
-	//! Used by create enum from query
-	unique_ptr<SQLStatement> query;
+	AlterFunctionType alter_function_type;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateTypeInfo>();
-		CopyProperties(*result);
-		result->name = name;
-		result->type = type;
-		if (query) {
-			result->query = query->Copy();
-		}
-		return move(result);
-	}
+	CatalogType GetCatalogType() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
+};
 
-protected:
-	void SerializeInternal(Serializer &) const override {
-		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(CreateInfo::type));
-	}
+//===--------------------------------------------------------------------===//
+// AddFunctionOverloadInfo
+//===--------------------------------------------------------------------===//
+struct AddFunctionOverloadInfo : public AlterFunctionInfo {
+	AddFunctionOverloadInfo(string schema, string name, bool if_exists, ScalarFunctionSet new_overloads);
+	~AddFunctionOverloadInfo() override;
+
+	ScalarFunctionSet new_overloads;
+
+public:
+	unique_ptr<AlterInfo> Copy() const override;
 };
 
 } // namespace duckdb
@@ -31539,7 +31772,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
+// duckdb/parser/parsed_data/show_select_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31551,28 +31784,23 @@ public:
 
 namespace duckdb {
 
-struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
-	explicit CreateAggregateFunctionInfo(AggregateFunction function)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
-		name = function.name;
-		functions.AddFunction(move(function));
-	}
-
-	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
-		name = functions.name;
-		for (auto &func : functions.functions) {
-			func.name = functions.name;
-		}
-	}
-
-	AggregateFunctionSet functions;
+struct ShowSelectInfo : public ParseInfo {
+	//! Types of projected columns
+	vector<LogicalType> types;
+	//! The QueryNode of select query
+	unique_ptr<QueryNode> query;
+	//! Aliases of projected columns
+	vector<string> aliases;
+	//! Whether or not we are requesting a summary or a describe
+	bool is_summary;
 
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
-		CopyProperties(*result);
-		return move(result);
+	unique_ptr<ShowSelectInfo> Copy() {
+		auto result = make_unique<ShowSelectInfo>();
+		result->types = types;
+		result->query = query->Copy();
+		result->aliases = aliases;
+		result->is_summary = is_summary;
+		return result;
 	}
 };
 
@@ -31580,7 +31808,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/vacuum_info.hpp
+// duckdb/parser/parsed_data/create_index_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31589,20 +31817,11 @@ public:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_basetableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/planner/bound_tableref.hpp
+// duckdb/parser/tableref/basetableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31612,163 +31831,78 @@ public:
 
 
 
-
-namespace duckdb {
-
-class BoundTableRef {
-public:
-	explicit BoundTableRef(TableReferenceType type) : type(type) {
-	}
-	virtual ~BoundTableRef() {
-	}
-
-	//! The type of table reference
-	TableReferenceType type;
-	//! The sample options (if any)
-	unique_ptr<SampleOptions> sample;
-};
-} // namespace duckdb
-
-
-
 namespace duckdb {
-class TableCatalogEntry;
-
 //! Represents a TableReference to a base table in the schema
-class BoundBaseTableRef : public BoundTableRef {
+class BaseTableRef : public TableRef {
 public:
-	BoundBaseTableRef(TableCatalogEntry *table, unique_ptr<LogicalOperator> get)
-	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(move(get)) {
+	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
 	}
 
-	TableCatalogEntry *table;
-	unique_ptr<LogicalOperator> get;
-};
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct VacuumOptions {
-	bool vacuum;
-	bool analyze;
-};
+	//! Schema name
+	string schema_name;
+	//! Table name
+	string table_name;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
 
-struct VacuumInfo : public ParseInfo {
 public:
-	explicit VacuumInfo(VacuumOptions options) : options(options), has_table(false), table(nullptr) {};
-
-	unique_ptr<VacuumInfo> Copy() {
-		auto result = make_unique<VacuumInfo>(options);
-		result->has_table = has_table;
-		if (has_table) {
-			result->ref = ref->Copy();
-		}
-		return result;
-	}
+	string ToString() const override;
+	bool Equals(const TableRef *other_p) const override;
 
-	const VacuumOptions options;
+	unique_ptr<TableRef> Copy() override;
 
-public:
-	bool has_table;
-	unique_ptr<TableRef> ref;
-	TableCatalogEntry *table;
-	unordered_map<idx_t, idx_t> column_id_map;
-	vector<string> columns;
+	//! Serializes a blob into a BaseTableRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a BaseTableRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
-
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/drop_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
 
 
 
 
 namespace duckdb {
 
-struct DropInfo : public ParseInfo {
-	DropInfo() : schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
-	}
-
-	//! The catalog type to drop
-	CatalogType type;
-	//! Schema name to drop from, if any
-	string schema;
-	//! Element name to drop
-	string name;
-	//! Ignore if the entry does not exist instead of failing
-	bool if_exists = false;
-	//! Cascade drop (drop all dependents instead of throwing an error if there
-	//! are any)
-	bool cascade = false;
-
-public:
-	unique_ptr<DropInfo> Copy() const {
-		auto result = make_unique<DropInfo>();
-		result->type = type;
-		result->schema = schema;
-		result->name = name;
-		result->if_exists = if_exists;
-		result->cascade = cascade;
-		return result;
+struct CreateIndexInfo : public CreateInfo {
+	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
 	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/export_table_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
 
+	//! Index Type (e.g., B+-tree, Skip-List, ...)
+	IndexType index_type;
+	//! Name of the Index
+	string index_name;
+	//! Index Constraint Type
+	IndexConstraintType constraint_type;
+	//! The table to create the index on
+	unique_ptr<BaseTableRef> table;
+	//! Set of expressions to index by
+	vector<unique_ptr<ParsedExpression>> expressions;
+	vector<unique_ptr<ParsedExpression>> parsed_expressions;
 
+	//! Types used for the CREATE INDEX scan
+	vector<LogicalType> scan_types;
+	//! The names of the columns, used for the CREATE INDEX scan
+	vector<string> names;
+	//! Column IDs needed for index creation
+	vector<column_t> column_ids;
 
+protected:
+	void SerializeInternal(Serializer &serializer) const override;
 
+public:
+	unique_ptr<CreateInfo> Copy() const override;
 
-namespace duckdb {
-class TableCatalogEntry;
-
-struct ExportedTableData {
-	//! Name of the exported table
-	string table_name;
-
-	//! Name of the schema
-	string schema_name;
-
-	//! Path to be exported
-	string file_path;
-};
-
-struct ExportedTableInfo {
-	TableCatalogEntry *entry;
-	ExportedTableData table_data;
-};
-
-struct BoundExportData : public ParseInfo {
-	std::vector<ExportedTableInfo> data;
+	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/alter_function_info.hpp
+// duckdb/parser/parsed_data/transaction_info.hpp
 //
 //
-//===----------------------------------------------------------------------===//
-
-
+//===----------------------------------------------------------------------===//
 
 
 
@@ -31776,34 +31910,14 @@ struct BoundExportData : public ParseInfo {
 
 namespace duckdb {
 
-//===--------------------------------------------------------------------===//
-// Alter Table
-//===--------------------------------------------------------------------===//
-enum class AlterFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
-
-struct AlterFunctionInfo : public AlterInfo {
-	AlterFunctionInfo(AlterFunctionType type, string schema, string name, bool if_exists);
-	virtual ~AlterFunctionInfo() override;
-
-	AlterFunctionType alter_function_type;
-
-public:
-	CatalogType GetCatalogType() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
-};
-
-//===--------------------------------------------------------------------===//
-// AddFunctionOverloadInfo
-//===--------------------------------------------------------------------===//
-struct AddFunctionOverloadInfo : public AlterFunctionInfo {
-	AddFunctionOverloadInfo(string schema, string name, bool if_exists, ScalarFunctionSet new_overloads);
-	~AddFunctionOverloadInfo() override;
+enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
 
-	ScalarFunctionSet new_overloads;
+struct TransactionInfo : public ParseInfo {
+	explicit TransactionInfo(TransactionType type) : type(type) {
+	}
 
-public:
-	unique_ptr<AlterInfo> Copy() const override;
+	//! The type of transaction statement
+	TransactionType type;
 };
 
 } // namespace duckdb
@@ -31840,7 +31954,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_view_info.hpp
+// duckdb/parser/parsed_data/export_table_data.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31851,63 +31965,33 @@ public:
 
 
 namespace duckdb {
+class TableCatalogEntry;
 
-struct CreateViewInfo : public CreateInfo {
-	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
-	}
-	CreateViewInfo(string schema, string view_name)
-	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
-	}
-
-	//! Table name to insert to
-	string view_name;
-	//! Aliases of the view
-	vector<string> aliases;
-	//! Return types
-	vector<LogicalType> types;
-	//! The SelectStatement of the view
-	unique_ptr<SelectStatement> query;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateViewInfo>(schema, view_name);
-		CopyProperties(*result);
-		result->aliases = aliases;
-		result->types = types;
-		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-		return move(result);
-	}
+struct ExportedTableData {
+	//! Name of the exported table
+	string table_name;
 
-	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &deserializer) {
-		auto result = make_unique<CreateViewInfo>();
-		result->DeserializeBase(deserializer);
+	//! Name of the schema
+	string schema_name;
 
-		FieldReader reader(deserializer);
-		result->view_name = reader.ReadRequired<string>();
-		result->aliases = reader.ReadRequiredList<string>();
-		result->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-		result->query = reader.ReadOptional<SelectStatement>(nullptr);
-		reader.Finalize();
+	//! Path to be exported
+	string file_path;
+};
 
-		return result;
-	}
+struct ExportedTableInfo {
+	TableCatalogEntry *entry;
+	ExportedTableData table_data;
+};
 
-protected:
-	void SerializeInternal(Serializer &serializer) const override {
-		FieldWriter writer(serializer);
-		writer.WriteString(view_name);
-		writer.WriteList<string>(aliases);
-		writer.WriteRegularSerializableList(types);
-		writer.WriteOptional(query);
-		writer.Finalize();
-	}
+struct BoundExportData : public ParseInfo {
+	std::vector<ExportedTableInfo> data;
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_schema_info.hpp
+// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31916,28 +32000,32 @@ protected:
 
 
 
+
 namespace duckdb {
 
-struct CreateSchemaInfo : public CreateInfo {
-	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
+struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
+	explicit CreateAggregateFunctionInfo(AggregateFunction function)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
+		name = function.name;
+		functions.AddFunction(move(function));
+	}
+
+	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
+		name = functions.name;
+		for (auto &func : functions.functions) {
+			func.name = functions.name;
+		}
 	}
 
+	AggregateFunctionSet functions;
+
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateSchemaInfo>();
+		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
 		CopyProperties(*result);
 		return move(result);
 	}
-
-	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &deserializer) {
-		auto result = make_unique<CreateSchemaInfo>();
-		result->DeserializeBase(deserializer);
-		return result;
-	}
-
-protected:
-	void SerializeInternal(Serializer &) const override {
-	}
 };
 
 } // namespace duckdb
@@ -32024,6 +32112,43 @@ public:
 	}
 };
 
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_schema_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct CreateSchemaInfo : public CreateInfo {
+	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
+	}
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateSchemaInfo>();
+		CopyProperties(*result);
+		return move(result);
+	}
+
+	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &deserializer) {
+		auto result = make_unique<CreateSchemaInfo>();
+		result->DeserializeBase(deserializer);
+		return result;
+	}
+
+protected:
+	void SerializeInternal(Serializer &) const override {
+	}
+};
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -32066,7 +32191,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/transaction_info.hpp
+// duckdb/parser/parsed_data/vacuum_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -32075,36 +32200,20 @@ public:
 
 
 
-namespace duckdb {
-
-enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
-
-struct TransactionInfo : public ParseInfo {
-	explicit TransactionInfo(TransactionType type) : type(type) {
-	}
-
-	//! The type of transaction statement
-	TransactionType type;
-};
-
-} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_index_info.hpp
+// duckdb/planner/tableref/bound_basetableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/basetableref.hpp
+// duckdb/planner/bound_tableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -32114,75 +32223,77 @@ struct TransactionInfo : public ParseInfo {
 
 
 
+
 namespace duckdb {
-//! Represents a TableReference to a base table in the schema
-class BaseTableRef : public TableRef {
+
+class BoundTableRef {
 public:
-	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
+	explicit BoundTableRef(TableReferenceType type) : type(type) {
+	}
+	virtual ~BoundTableRef() {
 	}
 
-	//! Schema name
-	string schema_name;
-	//! Table name
-	string table_name;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
+	//! The type of table reference
+	TableReferenceType type;
+	//! The sample options (if any)
+	unique_ptr<SampleOptions> sample;
+};
+} // namespace duckdb
 
-public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
 
-	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a BaseTableRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a BaseTableRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+namespace duckdb {
+class TableCatalogEntry;
+
+//! Represents a TableReference to a base table in the schema
+class BoundBaseTableRef : public BoundTableRef {
+public:
+	BoundBaseTableRef(TableCatalogEntry *table, unique_ptr<LogicalOperator> get)
+	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(move(get)) {
+	}
+
+	TableCatalogEntry *table;
+	unique_ptr<LogicalOperator> get;
 };
 } // namespace duckdb
 
 
 
-
 namespace duckdb {
 
-struct CreateIndexInfo : public CreateInfo {
-	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
-	}
+struct VacuumOptions {
+	bool vacuum;
+	bool analyze;
+};
 
-	//! Index Type (e.g., B+-tree, Skip-List, ...)
-	IndexType index_type;
-	//! Name of the Index
-	string index_name;
-	//! Index Constraint Type
-	IndexConstraintType constraint_type;
-	//! The table to create the index on
-	unique_ptr<BaseTableRef> table;
-	//! Set of expressions to index by
-	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<unique_ptr<ParsedExpression>> parsed_expressions;
+struct VacuumInfo : public ParseInfo {
+public:
+	explicit VacuumInfo(VacuumOptions options) : options(options), has_table(false), table(nullptr) {};
 
-	//! Types used for the CREATE INDEX scan
-	vector<LogicalType> scan_types;
-	//! The names of the columns, used for the CREATE INDEX scan
-	vector<string> names;
-	//! Column IDs needed for index creation
-	vector<column_t> column_ids;
+	unique_ptr<VacuumInfo> Copy() {
+		auto result = make_unique<VacuumInfo>(options);
+		result->has_table = has_table;
+		if (has_table) {
+			result->ref = ref->Copy();
+		}
+		return result;
+	}
 
-protected:
-	void SerializeInternal(Serializer &serializer) const override;
+	const VacuumOptions options;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override;
-
-	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &deserializer);
+	bool has_table;
+	unique_ptr<TableRef> ref;
+	TableCatalogEntry *table;
+	unordered_map<idx_t, idx_t> column_id_map;
+	vector<string> columns;
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/show_select_info.hpp
+// duckdb/parser/parsed_data/drop_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -32194,22 +32305,30 @@ public:
 
 namespace duckdb {
 
-struct ShowSelectInfo : public ParseInfo {
-	//! Types of projected columns
-	vector<LogicalType> types;
-	//! The QueryNode of select query
-	unique_ptr<QueryNode> query;
-	//! Aliases of projected columns
-	vector<string> aliases;
-	//! Whether or not we are requesting a summary or a describe
-	bool is_summary;
+struct DropInfo : public ParseInfo {
+	DropInfo() : schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
+	}
 
-	unique_ptr<ShowSelectInfo> Copy() {
-		auto result = make_unique<ShowSelectInfo>();
-		result->types = types;
-		result->query = query->Copy();
-		result->aliases = aliases;
-		result->is_summary = is_summary;
+	//! The catalog type to drop
+	CatalogType type;
+	//! Schema name to drop from, if any
+	string schema;
+	//! Element name to drop
+	string name;
+	//! Ignore if the entry does not exist instead of failing
+	bool if_exists = false;
+	//! Cascade drop (drop all dependents instead of throwing an error if there
+	//! are any)
+	bool cascade = false;
+
+public:
+	unique_ptr<DropInfo> Copy() const {
+		auto result = make_unique<DropInfo>();
+		result->type = type;
+		result->schema = schema;
+		result->name = name;
+		result->if_exists = if_exists;
+		result->cascade = cascade;
 		return result;
 	}
 };
@@ -32218,7 +32337,7 @@ struct ShowSelectInfo : public ParseInfo {
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/expressionlistref.hpp
+// duckdb/parser/parsed_data/create_type_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -32231,35 +32350,44 @@ struct ShowSelectInfo : public ParseInfo {
 
 
 namespace duckdb {
-//! Represents an expression list as generated by a VALUES statement
-class ExpressionListRef : public TableRef {
-public:
-	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
+
+struct CreateTypeInfo : public CreateInfo {
+	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+	}
+	CreateTypeInfo(string name_p, LogicalType type_p)
+	    : CreateInfo(CatalogType::TYPE_ENTRY), name(move(name_p)), type(move(type_p)) {
 	}
 
-	//! Value list, only used for VALUES statement
-	vector<vector<unique_ptr<ParsedExpression>>> values;
-	//! Expected SQL types
-	vector<LogicalType> expected_types;
-	//! The set of expected names
-	vector<string> expected_names;
+	//! Name of the Type
+	string name;
+	//! Logical Type
+	LogicalType type;
+	//! Used by create enum from query
+	unique_ptr<SQLStatement> query;
 
 public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateTypeInfo>();
+		CopyProperties(*result);
+		result->name = name;
+		result->type = type;
+		if (query) {
+			result->query = query->Copy();
+		}
+		return move(result);
+	}
 
-	//! Serializes a blob into a ExpressionListRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a ExpressionListRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+protected:
+	void SerializeInternal(Serializer &) const override {
+		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(CreateInfo::type));
+	}
 };
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/joinref.hpp
+// duckdb/parser/tableref/table_function_ref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -32273,41 +32401,38 @@ public:
 
 
 namespace duckdb {
-//! Represents a JOIN between two expressions
-class JoinRef : public TableRef {
+//! Represents a Table producing function
+class TableFunctionRef : public TableRef {
 public:
-	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
-	}
+	DUCKDB_API TableFunctionRef();
 
-	//! The left hand side of the join
-	unique_ptr<TableRef> left;
-	//! The right hand side of the join
-	unique_ptr<TableRef> right;
-	//! The join condition
-	unique_ptr<ParsedExpression> condition;
-	//! The join type
-	JoinType type;
-	//! Natural join
-	bool is_natural;
-	//! The set of USING columns (if any)
-	vector<string> using_columns;
+	unique_ptr<ParsedExpression> function;
+	vector<string> column_name_alias;
+
+	// if the function takes a subquery as argument its in here
+	unique_ptr<SelectStatement> subquery;
+
+	// External dependencies of this table funcion
+	unique_ptr<ExternalDependency> external_dependency;
 
 public:
 	string ToString() const override;
+
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a JoinRef
+	//! Serializes a blob into a BaseTableRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a JoinRef
+	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/subqueryref.hpp
+// duckdb/parser/tableref/crossproductref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -32316,17 +32441,17 @@ public:
 
 
 
-
 namespace duckdb {
-//! Represents a subquery
-class SubqueryRef : public TableRef {
+//! Represents a cross product
+class CrossProductRef : public TableRef {
 public:
-	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
+	CrossProductRef() : TableRef(TableReferenceType::CROSS_PRODUCT) {
+	}
 
-	//! The subquery
-	unique_ptr<SelectStatement> subquery;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
+	//! 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:
 	string ToString() const override;
@@ -32334,12 +32459,13 @@ public:
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a SubqueryRef
+	//! Serializes a blob into a CrossProductRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a SubqueryRef
+	//! Deserializes a blob back into a CrossProductRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -32371,10 +32497,11 @@ public:
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/crossproductref.hpp
+// duckdb/parser/tableref/expressionlistref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -32383,17 +32510,22 @@ public:
 
 
 
+
+
+
 namespace duckdb {
-//! Represents a cross product
-class CrossProductRef : public TableRef {
+//! Represents an expression list as generated by a VALUES statement
+class ExpressionListRef : public TableRef {
 public:
-	CrossProductRef() : TableRef(TableReferenceType::CROSS_PRODUCT) {
+	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
 	}
 
-	//! The left hand side of the cross product
-	unique_ptr<TableRef> left;
-	//! The right hand side of the cross product
-	unique_ptr<TableRef> right;
+	//! Value list, only used for VALUES statement
+	vector<vector<unique_ptr<ParsedExpression>>> values;
+	//! Expected SQL types
+	vector<LogicalType> expected_types;
+	//! The set of expected names
+	vector<string> expected_names;
 
 public:
 	string ToString() const override;
@@ -32401,16 +32533,17 @@ public:
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a CrossProductRef
+	//! Serializes a blob into a ExpressionListRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a CrossProductRef
+	//! Deserializes a blob back into a ExpressionListRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/table_function_ref.hpp
+// duckdb/parser/tableref/joinref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -32424,37 +32557,73 @@ public:
 
 
 namespace duckdb {
-//! Represents a Table producing function
-class TableFunctionRef : public TableRef {
+//! Represents a JOIN between two expressions
+class JoinRef : public TableRef {
 public:
-	DUCKDB_API TableFunctionRef();
-
-	unique_ptr<ParsedExpression> function;
-	vector<string> column_name_alias;
-
-	// if the function takes a subquery as argument its in here
-	unique_ptr<SelectStatement> subquery;
+	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
+	}
 
-	// External dependencies of this table funcion
-	unique_ptr<ExternalDependency> external_dependency;
+	//! The left hand side of the join
+	unique_ptr<TableRef> left;
+	//! The right hand side of the join
+	unique_ptr<TableRef> right;
+	//! The join condition
+	unique_ptr<ParsedExpression> condition;
+	//! The join type
+	JoinType type;
+	//! Natural join
+	bool is_natural;
+	//! The set of USING columns (if any)
+	vector<string> using_columns;
 
 public:
 	string ToString() const override;
-
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a BaseTableRef
+	//! Serializes a blob into a JoinRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a BaseTableRef
+	//! Deserializes a blob back into a JoinRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/subqueryref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+//! Represents a subquery
+class SubqueryRef : public TableRef {
+public:
+	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
 
+	//! The subquery
+	unique_ptr<SelectStatement> subquery;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
 
+public:
+	string ToString() const override;
+	bool Equals(const TableRef *other_p) const override;
 
+	unique_ptr<TableRef> Copy() override;
 
+	//! Serializes a blob into a SubqueryRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a SubqueryRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+};
+} // namespace duckdb