duckdb 0.3.1-dev8.0 → 0.3.2-dev121.0

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "32a4c9d48"
-#define DUCKDB_VERSION "0.3.1-dev8"
+#define DUCKDB_SOURCE_ID "3c9727ac2"
+#define DUCKDB_VERSION "0.3.2-dev121"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -567,11 +567,13 @@ using std::vector;
 #endif
 
 
+
 namespace duckdb {
 
 class Serializer;
 class Deserializer;
-
+class Value;
+class TypeCatalogEntry;
 //! Type used to represent dates (days since 1970-01-01)
 struct date_t {
 	int32_t days;
@@ -861,12 +863,12 @@ enum class PhysicalType : uint8_t {
 	/// Like LIST, but with 64-bit offsets
 	LARGE_LIST = 33,
 
-	// DuckDB Extensions
+	/// DuckDB Extensions
 	VARCHAR = 200, // our own string representation, different from STRING and LARGE_STRING above
 	INT128 = 204, // 128-bit integers
-
+	UNKNOWN = 205, // Unknown physical type of user defined types
 	/// Boolean as 1 bit, LSB bit-packed ordering
-	BIT = 205,
+	BIT = 206,
 
 	INVALID = 255
 };
@@ -879,7 +881,7 @@ enum class LogicalTypeId : uint8_t {
 	SQLNULL = 1, /* NULL type, used for constant NULL */
 	UNKNOWN = 2, /* unknown type, used for parameter expressions */
 	ANY = 3,     /* ANY type, used for functions that accept any type as parameter */
-
+	USER = 4, /* A User Defined Type (e.g., ENUMs before the binder) */
 	BOOLEAN = 10,
 	TINYINT = 11,
 	SMALLINT = 12,
@@ -913,7 +915,8 @@ enum class LogicalTypeId : uint8_t {
 	STRUCT = 100,
 	LIST = 101,
 	MAP = 102,
-	TABLE = 103
+	TABLE = 103,
+	ENUM = 104
 };
 
 struct ExtraTypeInfo;
@@ -922,6 +925,7 @@ struct LogicalType {
 	DUCKDB_API LogicalType();
 	DUCKDB_API LogicalType(LogicalTypeId id); // NOLINT: Allow implicit conversion from `LogicalTypeId`
 	DUCKDB_API LogicalType(LogicalTypeId id, shared_ptr<ExtraTypeInfo> type_info);
+
 	DUCKDB_API LogicalType(const LogicalType &other) :
 		id_(other.id_), physical_type_(other.physical_type_), type_info_(other.type_info_) {}
 
@@ -1018,10 +1022,11 @@ public:
 	// explicitly allowing these functions to be capitalized to be in-line with the remaining functions
 	DUCKDB_API static LogicalType DECIMAL(int width, int scale);                 // NOLINT
 	DUCKDB_API static LogicalType VARCHAR_COLLATION(string collation);           // NOLINT
-	DUCKDB_API static LogicalType LIST(LogicalType child);                       // NOLINT
-	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT
-	DUCKDB_API static LogicalType MAP(child_list_t<LogicalType> children);       // NOLINT
-
+	DUCKDB_API static LogicalType LIST( LogicalType child);                       // NOLINT
+	DUCKDB_API static LogicalType STRUCT( child_list_t<LogicalType> children);    // NOLINT
+	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT
+	DUCKDB_API static LogicalType ENUM(const string &enum_name, const vector<string> &ordered_data); // NOLINT
+	DUCKDB_API static LogicalType USER(const string &user_type_name); // NOLINT
 	//! A list of all NUMERIC types (integral and floating point types)
 	DUCKDB_API static const vector<LogicalType> NUMERIC;
 	//! A list of all INTEGRAL types
@@ -1043,6 +1048,21 @@ struct ListType {
 	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type);
 };
 
+struct UserType{
+	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
+};
+
+struct EnumType{
+	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
+	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string& key);
+	DUCKDB_API static const vector<string> &GetValuesInsertOrder(const LogicalType &type);
+	DUCKDB_API static idx_t GetSize(const LogicalType &type);
+	DUCKDB_API static const string& GetValue(const Value &val);
+	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
+	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
+	DUCKDB_API static PhysicalType GetPhysicalType(idx_t size);
+};
+
 struct StructType {
 	DUCKDB_API static const child_list_t<LogicalType> &GetChildTypes(const LogicalType &type);
 	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type, idx_t index);
@@ -1497,7 +1517,7 @@ public:
 	//! Write a string with a length prefix
 	void WriteString(const string &val) {
 		Write<uint32_t>((uint32_t)val.size());
-		if (val.size() > 0) {
+		if (!val.empty()) {
 			WriteData((const_data_ptr_t)val.c_str(), val.size());
 		}
 	}
@@ -1903,6 +1923,7 @@ public:
 	                   FileOpener *opener = nullptr);
 
 	FileSystem &fs;
+	string path;
 	unique_ptr<data_t[]> data;
 	idx_t offset;
 	idx_t total_written;
@@ -2113,6 +2134,9 @@ public:
 	sel_t *data() {
 		return sel_vector;
 	}
+	const sel_t *data() const {
+		return sel_vector;
+	}
 	buffer_ptr<SelectionData> sel_data() {
 		return selection_data;
 	}
@@ -2568,6 +2592,9 @@ public:
 	DUCKDB_API static Value INTERVAL(int32_t months, int32_t days, int64_t micros);
 	DUCKDB_API static Value INTERVAL(interval_t interval);
 
+	// Create a enum Value from a specified uint value
+	DUCKDB_API static Value ENUM(uint64_t value, const LogicalType &original_type);
+
 	// Decimal values
 	DUCKDB_API static Value DECIMAL(int16_t value, uint8_t width, uint8_t scale);
 	DUCKDB_API static Value DECIMAL(int32_t value, uint8_t width, uint8_t scale);
@@ -3293,6 +3320,9 @@ public:
 	//! Without changing the type of this vector
 	void Reinterpret(Vector &other);
 
+	//! Causes this vector to reference the data held by the other vector, changes the type if required.
+	void ReferenceAndSetType(Vector &other);
+
 	//! Resets a vector from a vector cache.
 	//! This turns the vector back into an empty FlatVector with STANDARD_VECTOR_SIZE entries.
 	//! The VectorCache is used so this can be done without requiring any allocations.
@@ -3631,12 +3661,15 @@ public:
 		return data.size();
 	}
 	void SetCardinality(idx_t count_p) {
-		D_ASSERT(count <= STANDARD_VECTOR_SIZE);
+		D_ASSERT(count_p <= capacity);
 		this->count = count_p;
 	}
 	void SetCardinality(const DataChunk &other) {
 		this->count = other.size();
 	}
+	void SetCapacity(const DataChunk &other) {
+		this->capacity = other.capacity;
+	}
 
 	DUCKDB_API Value GetValue(idx_t col_idx, idx_t index) const;
 	DUCKDB_API void SetValue(idx_t col_idx, idx_t index, const Value &val);
@@ -3655,10 +3688,10 @@ public:
 	void InitializeEmpty(const vector<LogicalType> &types);
 	//! Append the other DataChunk to this one. The column count and types of
 	//! the two DataChunks have to match exactly. Throws an exception if there
-	//! is not enough space in the chunk.
-	DUCKDB_API void Append(const DataChunk &other);
-	//! Append a selection of the other DataChunk to this one
-	DUCKDB_API void Append(const DataChunk &other, const SelectionVector &sel, idx_t count);
+	//! is not enough space in the chunk and resize is not allowed.
+	DUCKDB_API void Append(const DataChunk &other, bool resize = false, SelectionVector *sel = nullptr,
+	                       idx_t count = 0);
+
 	//! Destroy all data and columns owned by this DataChunk
 	DUCKDB_API void Destroy();
 
@@ -3710,6 +3743,8 @@ public:
 private:
 	//! The amount of tuples stored in the data chunk
 	idx_t count;
+	//! The amount of tuples that can be stored in the data chunk
+	idx_t capacity;
 	//! Vector caches, used to store data when ::Initialize is called
 	vector<VectorCache> vector_caches;
 };
@@ -5164,6 +5199,7 @@ enum class ExpressionType : uint8_t {
 	// -----------------------------
 	AGGREGATE = 100,
 	BOUND_AGGREGATE = 101,
+	GROUPING_FUNCTION = 102,
 
 	// -----------------------------
 	// Window Functions
@@ -5420,6 +5456,36 @@ protected:
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/compression_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class CompressionType : uint8_t {
+	COMPRESSION_AUTO = 0,
+	COMPRESSION_UNCOMPRESSED = 1,
+	COMPRESSION_CONSTANT = 2,
+	COMPRESSION_RLE = 3,
+	COMPRESSION_DICTIONARY = 4,
+	COMPRESSION_PFOR_DELTA = 5,
+	COMPRESSION_BITPACKING = 6,
+	COMPRESSION_FSST = 7
+};
+
+CompressionType CompressionTypeFromString(const string &str);
+string CompressionTypeToString(CompressionType type);
+
+} // namespace duckdb
+
 
 namespace duckdb {
 
@@ -5440,6 +5506,8 @@ public:
 	LogicalType type;
 	//! The default value of the column (if any)
 	unique_ptr<ParsedExpression> default_value;
+	//! Compression Type used for this column
+	CompressionType compression_type = CompressionType::COMPRESSION_AUTO;
 
 public:
 	ColumnDefinition Copy() const;
@@ -5895,6 +5963,8 @@ template <>
 bool Hugeint::TryCast(hugeint_t input, float &result);
 template <>
 bool Hugeint::TryCast(hugeint_t input, double &result);
+template <>
+bool Hugeint::TryCast(hugeint_t input, long double &result);
 
 template <>
 bool Hugeint::TryConvert(int8_t value, hugeint_t &result);
@@ -5916,6 +5986,8 @@ template <>
 bool Hugeint::TryConvert(float value, hugeint_t &result);
 template <>
 bool Hugeint::TryConvert(double value, hugeint_t &result);
+template <>
+bool Hugeint::TryConvert(long double value, hugeint_t &result);
 
 } // namespace duckdb
 
@@ -5943,8 +6015,9 @@ public:
 	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;
-	static constexpr const int64_t DAYS_PER_MONTH =
-	    30; // only used for interval comparison/ordering purposes, in which case a month counts as 30 days
+	//! 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;
@@ -5975,13 +6048,19 @@ public:
 	//! 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(interval_t date);
+	static string ToString(const interval_t &val);
+
+	//! Convert milliseconds to a normalised interval
+	static interval_t FromMicro(int64_t micros);
 
 	//! Get Interval in milliseconds
-	static int64_t GetMilli(interval_t val);
+	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(interval_t val);
+	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);
@@ -5989,6 +6068,12 @@ public:
 	//! Returns the exact difference between two timestamps (days and seconds)
 	static interval_t GetDifference(timestamp_t timestamp_1, timestamp_t timestamp_2);
 
+	//! Add an interval to a date
+	static date_t Add(date_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);
@@ -7134,6 +7219,7 @@ enum class CatalogType : uint8_t {
 	PREPARED_STATEMENT = 5,
 	SEQUENCE_ENTRY = 6,
 	COLLATION_ENTRY = 7,
+	TYPE_ENTRY = 8,
 
 	// functions
 	TABLE_FUNCTION_ENTRY = 25,
@@ -7302,6 +7388,7 @@ struct CreateFunctionInfo;
 struct CreateViewInfo;
 struct CreateSequenceInfo;
 struct CreateCollationInfo;
+struct CreateTypeInfo;
 
 class ClientContext;
 class Transaction;
@@ -7390,6 +7477,8 @@ public:
 	CatalogEntry *CreateView(ClientContext &context, CreateViewInfo *info);
 	//! Creates a table in the catalog.
 	CatalogEntry *CreateSequence(ClientContext &context, CreateSequenceInfo *info);
+	//! Creates a Enum in the catalog.
+	CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
 	//! Creates a collation in the catalog
 	CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
 
@@ -7409,6 +7498,8 @@ public:
 	CatalogEntry *CreateView(ClientContext &context, SchemaCatalogEntry *schema, CreateViewInfo *info);
 	//! Creates a table in the catalog.
 	CatalogEntry *CreateSequence(ClientContext &context, SchemaCatalogEntry *schema, CreateSequenceInfo *info);
+	//! Creates a enum in the catalog.
+	CatalogEntry *CreateType(ClientContext &context, SchemaCatalogEntry *schema, CreateTypeInfo *info);
 	//! Creates a collation in the catalog
 	CatalogEntry *CreateCollation(ClientContext &context, SchemaCatalogEntry *schema, CreateCollationInfo *info);
 
@@ -7555,6 +7646,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_DROP = 132,
 	LOGICAL_PRAGMA = 133,
 	LOGICAL_TRANSACTION = 134,
+	LOGICAL_CREATE_TYPE = 135,
 
 	// -----------------------------
 	// Explain
@@ -8044,20 +8136,19 @@ public:
 	                  aggregate_combine_t combine, aggregate_finalize_t finalize,
 	                  aggregate_simple_update_t simple_update = nullptr, bind_aggregate_function_t bind = nullptr,
 	                  aggregate_destructor_t destructor = nullptr, aggregate_statistics_t statistics = nullptr,
-	                  aggregate_window_t window = nullptr, bool order_sensitive = false)
+	                  aggregate_window_t window = nullptr)
 	    : BaseScalarFunction(name, arguments, return_type, false), state_size(state_size), initialize(initialize),
 	      update(update), combine(combine), finalize(finalize), simple_update(simple_update), window(window),
-	      order_sensitive(order_sensitive), bind(bind), destructor(destructor), statistics(statistics) {
+	      bind(bind), destructor(destructor), statistics(statistics) {
 	}
 
 	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
 	                  aggregate_initialize_t initialize, aggregate_update_t update, aggregate_combine_t combine,
 	                  aggregate_finalize_t finalize, aggregate_simple_update_t simple_update = nullptr,
 	                  bind_aggregate_function_t bind = nullptr, aggregate_destructor_t destructor = nullptr,
-	                  aggregate_statistics_t statistics = nullptr, aggregate_window_t window = nullptr,
-	                  bool order_sensitive = false)
+	                  aggregate_statistics_t statistics = nullptr, aggregate_window_t window = nullptr)
 	    : AggregateFunction(string(), arguments, return_type, state_size, initialize, update, combine, finalize,
-	                        simple_update, bind, destructor, statistics, window, order_sensitive) {
+	                        simple_update, bind, destructor, statistics, window) {
 	}
 
 	//! The hashed aggregate state sizing function
@@ -8074,8 +8165,6 @@ public:
 	aggregate_simple_update_t simple_update;
 	//! The windowed aggregate frame update function (may be null)
 	aggregate_window_t window;
-	//! True if the aggregate is order-sensitive
-	bool order_sensitive;
 
 	//! The bind function (may be null)
 	bind_aggregate_function_t bind;
@@ -8830,9 +8919,10 @@ public:
 	//! Fetches a DataChunk of normalized (flat) vectors from the query result.
 	//! Returns nullptr if there are no more results to fetch.
 	DUCKDB_API virtual unique_ptr<DataChunk> Fetch();
-	//! Fetches a DataChunk from the query result. The vector types
+	//! Fetches a DataChunk from the query result. The vectors are not normalized and hence any vector types can be
+	//! returned.
 	DUCKDB_API virtual unique_ptr<DataChunk> FetchRaw() = 0;
-	// Converts the QueryResult to a string
+	//! Converts the QueryResult to a string
 	DUCKDB_API virtual string ToString() = 0;
 	//! Prints the QueryResult to the console
 	DUCKDB_API void Print();
@@ -9146,6 +9236,7 @@ string RelationTypeToString(RelationType type);
 
 
 
+
 #include <memory>
 
 namespace duckdb {
@@ -9249,7 +9340,10 @@ public:
 	//! Delete from a table, can only be used on a TableRelation
 	DUCKDB_API virtual void Delete(const string &condition = string());
 	//! Create a relation from calling a table in/out function on the input relation
-	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, vector<Value> values);
+	//! Create a relation from calling a table in/out function on the input relation
+	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values);
+	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values,
+	                                              const unordered_map<string, Value> &named_parameters);
 
 public:
 	//! Whether or not the relation inherits column bindings from its child or not, only relevant for binding
@@ -9492,6 +9586,8 @@ public:
 	DUCKDB_API shared_ptr<Relation> View(const string &schema_name, const string &table_name);
 	//! Returns a relation that calls a specified table function
 	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname);
+	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values,
+	                                              const unordered_map<string, Value> &named_parameters);
 	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values);
 	//! Returns a relation that produces values
 	DUCKDB_API shared_ptr<Relation> Values(const vector<vector<Value>> &values);
@@ -9504,7 +9600,7 @@ public:
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file);
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, const vector<string> &columns);
 	//! Returns a relation from a query
-	DUCKDB_API shared_ptr<Relation> RelationFromQuery(string query, string alias = "queryrelation");
+	DUCKDB_API shared_ptr<Relation> RelationFromQuery(const string &query, const string &alias = "queryrelation");
 
 	DUCKDB_API void BeginTransaction();
 	DUCKDB_API void Commit();
@@ -9911,35 +10007,6 @@ namespace duckdb {
 using std::set;
 }
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/compression_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class CompressionType : uint8_t {
-	COMPRESSION_INVALID = 0,
-	COMPRESSION_UNCOMPRESSED = 1,
-	COMPRESSION_CONSTANT = 2,
-	COMPRESSION_RLE = 3,
-	COMPRESSION_DICTIONARY = 4,
-	COMPRESSION_PFOR_DELTA = 5,
-	COMPRESSION_BITPACKING = 6,
-	COMPRESSION_FSST = 7
-};
-
-CompressionType CompressionTypeFromString(const string &str);
-string CompressionTypeToString(CompressionType type);
-
-} // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -9977,6 +10044,54 @@ string OptimizerTypeToString(OptimizerType type);
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/window_aggregation_mode.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class WindowAggregationMode : uint32_t {
+	//! Use the window aggregate API if available
+	WINDOW = 0,
+	//! Don't use window, but use combine if available
+	COMBINE,
+	//! Don't use combine or window (compute each frame separately)
+	SEPARATE
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/set_scope.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class SetScope : uint8_t {
+	AUTOMATIC = 0,
+	LOCAL = 1, /* unused */
+	SESSION = 2,
+	GLOBAL = 3
+};
+
+} // namespace duckdb
+
 
 namespace duckdb {
 class ClientContext;
@@ -9984,6 +10099,7 @@ class TableFunctionRef;
 class CompressionFunction;
 
 struct CompressionFunctionSet;
+struct DBConfig;
 
 enum class AccessMode : uint8_t { UNDEFINED = 0, AUTOMATIC = 1, READ_ONLY = 2, READ_WRITE = 3 };
 
@@ -9994,25 +10110,31 @@ enum class CheckpointAbort : uint8_t {
 	DEBUG_ABORT_AFTER_FREE_LIST_WRITE = 3
 };
 
-enum class ConfigurationOptionType : uint32_t {
-	INVALID = 0,
-	ACCESS_MODE,
-	DEFAULT_ORDER_TYPE,
-	DEFAULT_NULL_ORDER,
-	ENABLE_EXTERNAL_ACCESS,
-	ENABLE_OBJECT_CACHE,
-	MAXIMUM_MEMORY,
-	THREADS
-};
+typedef void (*set_global_function_t)(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+typedef void (*set_local_function_t)(ClientContext &context, const Value &parameter);
+typedef Value (*get_setting_function_t)(ClientContext &context);
 
 struct ConfigurationOption {
-	ConfigurationOptionType type;
 	const char *name;
 	const char *description;
 	LogicalTypeId parameter_type;
+	set_global_function_t set_global;
+	set_local_function_t set_local;
+	get_setting_function_t get_setting;
+};
+
+typedef void (*set_option_callback_t)(ClientContext &context, SetScope scope, Value &parameter);
+
+struct ExtensionOption {
+	ExtensionOption(string description_p, LogicalType type_p, set_option_callback_t set_function_p)
+	    : description(move(description_p)), type(move(type_p)), set_function(set_function_p) {
+	}
+
+	string description;
+	LogicalType type;
+	set_option_callback_t set_function;
 };
 
-// this is optional and only used in tests at the moment
 struct DBConfig {
 	friend class DatabaseInstance;
 	friend class StorageManager;
@@ -10029,6 +10151,8 @@ public:
 	idx_t checkpoint_wal_size = 1 << 24;
 	//! Whether or not to use Direct IO, bypassing operating system buffers
 	bool use_direct_io = false;
+	//! Whether extensions should be loaded on start-up
+	bool load_extensions = true;
 	//! The FileSystem to use, can be overwritten to allow for injecting custom file systems for testing purposes (e.g.
 	//! RamFS or something similar)
 	unique_ptr<FileSystem> file_system;
@@ -10050,8 +10174,6 @@ public:
 	bool enable_external_access = true;
 	//! Whether or not object cache is used
 	bool object_cache_enable = false;
-	//! Database configuration variables as controlled by SET
-	case_insensitive_map_t<Value> set_variables;
 	//! Force checkpoint when CHECKPOINT is called or on shutdown, even if no changes have been made
 	bool force_checkpoint = false;
 	//! Run a checkpoint on successful shutdown and delete the WAL, to leave only a single database file behind
@@ -10066,9 +10188,22 @@ public:
 	//! The set of disabled optimizers (default empty)
 	set<OptimizerType> disabled_optimizers;
 	//! Force a specific compression method to be used when checkpointing (if available)
-	CompressionType force_compression = CompressionType::COMPRESSION_INVALID;
+	CompressionType force_compression = CompressionType::COMPRESSION_AUTO;
 	//! Debug flag that adds additional (unnecessary) free_list blocks to the storage
 	bool debug_many_free_list_blocks = false;
+	//! Debug setting for window aggregation mode: (window, combine, separate)
+	WindowAggregationMode window_mode = WindowAggregationMode::WINDOW;
+
+	//! Extra parameters that can be SET for loaded extensions
+	case_insensitive_map_t<ExtensionOption> extension_parameters;
+	//! Database configuration variables as controlled by SET
+	case_insensitive_map_t<Value> set_variables;
+
+	void AddExtensionOption(string name, string description, LogicalType parameter,
+	                        set_option_callback_t function = nullptr) {
+		extension_parameters.insert(
+		    make_pair(move(name), ExtensionOption(move(description), move(parameter), function)));
+	}
 
 public:
 	DUCKDB_API static DBConfig &GetConfig(ClientContext &context);
@@ -12015,6 +12150,194 @@ using std::pair;
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/table_catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/standard_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class SchemaCatalogEntry;
+
+//! A StandardEntry is a catalog entry that is a member of a schema
+class StandardEntry : public CatalogEntry {
+public:
+	StandardEntry(CatalogType type, SchemaCatalogEntry *schema, Catalog *catalog, string name)
+	    : CatalogEntry(type, catalog, name), schema(schema) {
+	}
+	~StandardEntry() override {
+	}
+
+	//! The schema the entry belongs to
+	SchemaCatalogEntry *schema;
+};
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/constraint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+class Serializer;
+class Deserializer;
+
+//===--------------------------------------------------------------------===//
+// Constraint Types
+//===--------------------------------------------------------------------===//
+enum class ConstraintType : uint8_t {
+	INVALID = 0,    // invalid constraint type
+	NOT_NULL = 1,   // NOT NULL constraint
+	CHECK = 2,      // CHECK constraint
+	UNIQUE = 3,     // UNIQUE constraint
+	FOREIGN_KEY = 4 // FOREIGN KEY constraint
+};
+
+//! Constraint is the base class of any type of table constraint.
+class Constraint {
+public:
+	explicit Constraint(ConstraintType type) : type(type) {};
+	virtual ~Constraint() {
+	}
+
+	ConstraintType type;
+
+public:
+	virtual string ToString() const = 0;
+	void Print();
+
+	virtual unique_ptr<Constraint> Copy() = 0;
+	//! Serializes a Constraint to a stand-alone binary blob
+	virtual void Serialize(Serializer &serializer);
+	//! Deserializes a blob back into a Constraint, returns NULL if
+	//! deserialization is not possible
+	static unique_ptr<Constraint> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/bound_constraint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+//! Bound equivalent of Constraint
+class BoundConstraint {
+public:
+	explicit BoundConstraint(ConstraintType type) : type(type) {};
+	virtual ~BoundConstraint() {
+	}
+
+	ConstraintType type;
+};
+} // namespace duckdb
+
+
+
+
+namespace duckdb {
+
+class ColumnStatistics;
+class DataTable;
+struct CreateTableInfo;
+struct BoundCreateTableInfo;
+
+struct RenameColumnInfo;
+struct AddColumnInfo;
+struct RemoveColumnInfo;
+struct SetDefaultInfo;
+struct ChangeColumnTypeInfo;
+
+//! A table catalog entry
+class TableCatalogEntry : public StandardEntry {
+public:
+	//! Create a real TableCatalogEntry and initialize storage for it
+	TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
+	                  std::shared_ptr<DataTable> inherited_storage = nullptr);
+
+	//! A reference to the underlying storage unit used for this table
+	std::shared_ptr<DataTable> storage;
+	//! A list of columns that are part of this table
+	vector<ColumnDefinition> columns;
+	//! A list of constraints that are part of this table
+	vector<unique_ptr<Constraint>> constraints;
+	//! A list of constraints that are part of this table
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
+	//! A map of column name to column index
+	case_insensitive_map_t<column_t> name_map;
+
+public:
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
+	//! Returns whether or not a column with the given name exists
+	bool ColumnExists(const string &name);
+	//! Returns a reference to the column of the specified name. Throws an
+	//! exception if the column does not exist.
+	ColumnDefinition &GetColumn(const string &name);
+	//! Returns a list of types of the table
+	vector<LogicalType> GetTypes();
+	string ToSQL() override;
+
+	//! Serialize the meta information of the TableCatalogEntry a serializer
+	virtual void Serialize(Serializer &serializer);
+	//! Deserializes to a CreateTableInfo
+	static unique_ptr<CreateTableInfo> Deserialize(Deserializer &source);
+
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
+
+	void SetAsRoot() override;
+
+	void CommitAlter(AlterInfo &info);
+	void CommitDrop();
+
+	//! Returns the column index of the specified column name.
+	//! If the column does not exist:
+	//! If if_exists is true, returns INVALID_INDEX
+	//! If if_exists is false, throws an exception
+	idx_t GetColumnIndex(string &name, bool if_exists = false);
+
+private:
+	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
+	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);
+	unique_ptr<CatalogEntry> RemoveColumn(ClientContext &context, RemoveColumnInfo &info);
+	unique_ptr<CatalogEntry> SetDefault(ClientContext &context, SetDefaultInfo &info);
+	unique_ptr<CatalogEntry> ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info);
+};
+} // namespace duckdb
+
 #include <functional>
 #include <memory>
 
@@ -12084,6 +12407,12 @@ public:
 	void UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp);
 
 private:
+	//! Adjusts table dependencies on the event of an UNDO
+	void AdjustTableDependencies(CatalogEntry *entry);
+	//! Adjust one dependency
+	void AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table, ColumnDefinition &column, bool remove);
+	//! Adjust Enum dependency
+	void AdjustEnumDependency(CatalogEntry *entry, ColumnDefinition &column, bool remove);
 	//! Given a root entry, gets the entry valid for this transaction
 	CatalogEntry *GetEntryForTransaction(ClientContext &context, CatalogEntry *current);
 	CatalogEntry *GetCommittedEntry(CatalogEntry *current);
@@ -12138,6 +12467,7 @@ struct CreateSequenceInfo;
 struct CreateSchemaInfo;
 struct CreateTableFunctionInfo;
 struct CreateCopyFunctionInfo;
+struct CreateTypeInfo;
 
 struct DropInfo;
 
@@ -12165,6 +12495,8 @@ private:
 	CatalogSet sequences;
 	//! The catalog set holding the collations
 	CatalogSet collations;
+	//! The catalog set holding the types
+	CatalogSet types;
 
 public:
 	//! Scan the specified catalog set, invoking the callback method for every entry
@@ -12199,6 +12531,8 @@ private:
 	CatalogEntry *CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info);
 	//! Create a collation within the given schema
 	CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
+	//! Create a enum within the given schema
+	CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
 
 	//! Drops an entry from the schema
 	void DropEntry(ClientContext &context, DropInfo *info);
@@ -12218,7 +12552,6 @@ private:
 } // namespace duckdb
 
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -12234,24 +12567,6 @@ private:
 namespace duckdb {
 using std::deque;
 }
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/output_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class ExplainOutputType : uint8_t { ALL = 0, OPTIMIZED_ONLY = 1, PHYSICAL_ONLY = 2 };
-
-} // namespace duckdb
-
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -12307,16 +12622,6 @@ using std::thread;
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/physical_sink.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -12407,11 +12712,13 @@ enum class PhysicalOperatorType : uint8_t {
 	DROP,
 	PRAGMA,
 	TRANSACTION,
+	CREATE_TYPE,
 
 	// -----------------------------
 	// Helpers
 	// -----------------------------
 	EXPLAIN,
+	EXPLAIN_ANALYZE,
 	EMPTY_RESULT,
 	EXECUTE,
 	PREPARE,
@@ -12442,60 +12749,110 @@ string PhysicalOperatorToString(PhysicalOperatorType type);
 namespace duckdb {
 class ClientContext;
 class ThreadContext;
-class TaskContext;
 
 class ExecutionContext {
 public:
-	ExecutionContext(ClientContext &client_p, ThreadContext &thread_p, TaskContext &task_p)
-	    : client(client_p), thread(thread_p), task(task_p) {
+	ExecutionContext(ClientContext &client_p, ThreadContext &thread_p) : client(client_p), thread(thread_p) {
 	}
 
 	//! The client-global context; caution needs to be taken when used in parallel situations
 	ClientContext &client;
 	//! The thread-local context for this execution
 	ThreadContext &thread;
-	//! The task context for this execution
-	TaskContext &task;
 };
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/operator_result_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
 
 
-#include <functional>
-#include <utility>
 
 namespace duckdb {
-class ExpressionExecutor;
+
+//! The OperatorResultType is used to indicate how data should flow around a regular (i.e. non-sink and non-source)
+//! physical operator
+//! There are three possible results:
+//! NEED_MORE_INPUT means the operator is done with the current input and can consume more input if available
+//! If there is more input the operator will be called with more input, otherwise the operator will not be called again.
+//! HAVE_MORE_OUTPUT means the operator is not finished yet with the current input.
+//! The operator will be called again with the same input.
+//! FINISHED means the operator has finished the entire pipeline and no more processing is necessary.
+//! The operator will not be called again, and neither will any other operators in this pipeline.
+enum class OperatorResultType : uint8_t { NEED_MORE_INPUT, HAVE_MORE_OUTPUT, FINISHED };
+
+//! The SinkResultType is used to indicate the result of data flowing into a sink
+//! There are two possible results:
+//! NEED_MORE_INPUT means the sink needs more input
+//! FINISHED means the sink is finished executing, and more input will not change the result any further
+enum class SinkResultType : uint8_t { NEED_MORE_INPUT, FINISHED };
+
+//! The SinkFinalizeType is used to indicate the result of a Finalize call on a sink
+//! There are two possible results:
+//! READY means the sink is ready for further processing
+//! NO_OUTPUT_POSSIBLE means the sink will never provide output, and any pipelines involving the sink can be skipped
+enum class SinkFinalizeType : uint8_t { READY, NO_OUTPUT_POSSIBLE };
+
+} // namespace duckdb
+
+
+namespace duckdb {
+class Event;
 class PhysicalOperator;
+class Pipeline;
 
-//! The current state/context of the operator. The PhysicalOperatorState is
-//! updated using the GetChunk function, and allows the caller to repeatedly
-//! call the GetChunk function and get new batches of data everytime until the
-//! data source is exhausted.
-class PhysicalOperatorState {
+// LCOV_EXCL_START
+class OperatorState {
 public:
-	PhysicalOperatorState(PhysicalOperator &op, PhysicalOperator *child);
-	virtual ~PhysicalOperatorState() = default;
+	virtual ~OperatorState() {
+	}
 
-	//! Flag indicating whether or not the operator is finished [note: not all
-	//! operators use this flag]
-	bool finished;
-	//! DataChunk that stores data from the child of this operator
-	DataChunk child_chunk;
-	//! State of the child of this operator
-	unique_ptr<PhysicalOperatorState> child_state;
+	virtual void Finalize(PhysicalOperator *op, ExecutionContext &context) {
+	}
 };
 
+class GlobalSinkState {
+public:
+	GlobalSinkState() : state(SinkFinalizeType::READY) {
+	}
+	virtual ~GlobalSinkState() {
+	}
+
+	SinkFinalizeType state;
+};
+
+class LocalSinkState {
+public:
+	virtual ~LocalSinkState() {
+	}
+};
+
+class GlobalSourceState {
+public:
+	virtual ~GlobalSourceState() {
+	}
+
+	virtual idx_t MaxThreads() {
+		return 1;
+	}
+};
+
+class LocalSourceState {
+public:
+	virtual ~LocalSourceState() {
+	}
+};
+// LCOV_EXCL_STOP
+
 //! PhysicalOperator is the base class of the physical operators present in the
 //! execution plan
-/*!
-    The execution model is a pull-based execution model. GetChunk is called on
-   the root node, which causes the root node to be executed, and presumably call
-   GetChunk again on its child nodes. Every node in the operator chain has a
-   state that is updated as GetChunk is called: PhysicalOperatorState (different
-   operators subclass this state and add different properties).
-*/
 class PhysicalOperator {
 public:
 	PhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality)
@@ -12512,6 +12869,8 @@ public:
 	vector<LogicalType> types;
 	//! The extimated cardinality of this physical operator
 	idx_t estimated_cardinality;
+	//! The global sink state of this operator
+	unique_ptr<GlobalSinkState> sink_state;
 
 public:
 	virtual string GetName() const;
@@ -12519,97 +12878,78 @@ public:
 		return "";
 	}
 	virtual string ToString() const;
-	void Print();
+	void Print() const;
 
 	//! Return a vector of the types that will be returned by this operator
-	vector<LogicalType> &GetTypes() {
+	const vector<LogicalType> &GetTypes() const {
 		return types;
 	}
-	//! Initialize a given chunk to the types that will be returned by this
-	//! operator, this will prepare chunk for a call to GetChunk. This method
-	//! only has to be called once for any amount of calls to GetChunk.
-	virtual void InitializeChunk(DataChunk &chunk) {
-		auto &types = GetTypes();
-		chunk.Initialize(types);
-	}
-	//! Retrieves a chunk from this operator and stores it in the chunk
-	//! variable.
-	virtual void GetChunkInternal(ExecutionContext &context, DataChunk &chunk, PhysicalOperatorState *state) const = 0;
 
-	void GetChunk(ExecutionContext &context, DataChunk &chunk, PhysicalOperatorState *state) const;
-
-	//! Create a new empty instance of the operator state
-	virtual unique_ptr<PhysicalOperatorState> GetOperatorState() {
-		return make_unique<PhysicalOperatorState>(*this, children.size() == 0 ? nullptr : children[0].get());
+	virtual bool Equals(const PhysicalOperator &other) const {
+		return false;
 	}
 
-	virtual void FinalizeOperatorState(PhysicalOperatorState &state, ExecutionContext &context) {
-		if (!children.empty() && state.child_state) {
-			children[0]->FinalizeOperatorState(*state.child_state, context);
-		}
-	}
+public:
+	// Operator interface
+	virtual unique_ptr<OperatorState> GetOperatorState(ClientContext &context) const;
+	virtual OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+	                                   OperatorState &state) const;
 
-	virtual bool IsSink() const {
+	virtual bool ParallelOperator() const {
 		return false;
 	}
-};
-
-} // namespace duckdb
-
 
-namespace duckdb {
-
-class Pipeline;
-
-class GlobalOperatorState {
-public:
-	virtual ~GlobalOperatorState() {
+	virtual bool RequiresCache() const {
+		return false;
 	}
-};
 
-class LocalSinkState {
 public:
-	virtual ~LocalSinkState() {
-	}
-};
+	// Source interface
+	virtual unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
+	                                                         GlobalSourceState &gstate) const;
+	virtual unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const;
+	virtual void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+	                     LocalSourceState &lstate) const;
 
-class PhysicalSink : public PhysicalOperator {
-public:
-	PhysicalSink(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality)
-	    : PhysicalOperator(type, move(types), estimated_cardinality) {
+	virtual bool IsSource() const {
+		return false;
 	}
 
-	unique_ptr<GlobalOperatorState> sink_state;
+	virtual bool ParallelSource() const {
+		return false;
+	}
 
 public:
+	// Sink interface
+
 	//! The sink method is called constantly with new input, as long as new input is available. Note that this method
-	//! CAN be called in parallel, proper locking is needed when accessing data inside the GlobalOperatorState.
-	virtual void Sink(ExecutionContext &context, GlobalOperatorState &gstate, LocalSinkState &lstate,
-	                  DataChunk &input) const = 0;
+	//! CAN be called in parallel, proper locking is needed when accessing data inside the GlobalSinkState.
+	virtual SinkResultType Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
+	                            DataChunk &input) const;
 	// The combine is called when a single thread has completed execution of its part of the pipeline, it is the final
 	// time that a specific LocalSinkState is accessible. This method can be called in parallel while other Sink() or
-	// Combine() calls are active on the same GlobalOperatorState.
-	virtual void Combine(ExecutionContext &context, GlobalOperatorState &gstate, LocalSinkState &lstate) {
-	}
+	// Combine() calls are active on the same GlobalSinkState.
+	virtual void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const;
 	//! The finalize is called when ALL threads are finished execution. It is called only once per pipeline, and is
 	//! entirely single threaded.
-	virtual bool Finalize(Pipeline &pipeline, ClientContext &context, unique_ptr<GlobalOperatorState> gstate) {
-		this->sink_state = move(gstate);
-		return true;
-	}
+	//! If Finalize returns SinkResultType::FINISHED, the sink is marked as finished
+	virtual SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+	                                  GlobalSinkState &gstate) const;
 
-	virtual unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) {
-		return make_unique<LocalSinkState>();
-	}
-	virtual unique_ptr<GlobalOperatorState> GetGlobalState(ClientContext &context) {
-		return make_unique<GlobalOperatorState>();
+	virtual unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const;
+	virtual unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const;
+
+	virtual bool IsSink() const {
+		return false;
 	}
 
-	bool IsSink() const override {
-		return true;
+	virtual bool ParallelSink() const {
+		return false;
 	}
 
-	void Schedule(ClientContext &context);
+	virtual bool SinkOrderMatters() const {
+		return false;
+	}
 };
 
 } // namespace duckdb
@@ -12668,7 +13008,9 @@ typedef void (*table_function_cleanup_t)(ClientContext &context, const FunctionD
                                          FunctionOperatorData *operator_state);
 typedef idx_t (*table_function_max_threads_t)(ClientContext &context, const FunctionData *bind_data);
 typedef unique_ptr<ParallelState> (*table_function_init_parallel_state_t)(ClientContext &context,
-                                                                          const FunctionData *bind_data);
+                                                                          const FunctionData *bind_data,
+                                                                          const vector<column_t> &column_ids,
+                                                                          TableFilterCollection *filters);
 typedef unique_ptr<FunctionOperatorData> (*table_function_init_parallel_t)(ClientContext &context,
                                                                            const FunctionData *bind_data,
                                                                            ParallelState *state,
@@ -12820,7 +13162,10 @@ struct ParallelState {
 
 
 namespace duckdb {
+class ClientContext;
+class Executor;
 
+//! Generic parallel task
 class Task {
 public:
 	virtual ~Task() {
@@ -12830,6 +13175,21 @@ public:
 	virtual void Execute() = 0;
 };
 
+//! Execute a task within an executor, including exception handling
+//! This should be used within queries
+class ExecutorTask : public Task {
+public:
+	ExecutorTask(Executor &executor);
+	ExecutorTask(ClientContext &context);
+	virtual ~ExecutorTask();
+
+	Executor &executor;
+
+public:
+	virtual void ExecuteTask() = 0;
+	void Execute() override;
+};
+
 } // namespace duckdb
 
 
@@ -12839,6 +13199,7 @@ namespace duckdb {
 struct ConcurrentQueue;
 struct QueueProducerToken;
 class ClientContext;
+class DatabaseInstance;
 class TaskScheduler;
 
 struct SchedulerThread;
@@ -12862,6 +13223,7 @@ public:
 	~TaskScheduler();
 
 	static TaskScheduler &GetScheduler(ClientContext &context);
+	static TaskScheduler &GetScheduler(DatabaseInstance &db);
 
 	unique_ptr<ProducerToken> CreateProducer();
 	//! Schedule a task to be executed by the task scheduler
@@ -12894,111 +13256,91 @@ private:
 
 namespace duckdb {
 class Executor;
-class TaskContext;
+class Event;
 
 //! The Pipeline class represents an execution pipeline
 class Pipeline : public std::enable_shared_from_this<Pipeline> {
 	friend class Executor;
+	friend class PipelineExecutor;
+	friend class PipelineEvent;
+	friend class PipelineFinishEvent;
 
 public:
-	Pipeline(Executor &execution_context, ProducerToken &token);
+	Pipeline(Executor &execution_context);
 
 	Executor &executor;
-	ProducerToken &token;
 
 public:
-	//! Execute a task within the pipeline on a single thread
-	void Execute(TaskContext &task);
+	ClientContext &GetClientContext();
 
 	void AddDependency(shared_ptr<Pipeline> &pipeline);
-	void CompleteDependency();
-	bool HasDependencies() {
-		return !dependencies.empty();
-	}
 
-	void Reset(ClientContext &context);
-	void Schedule();
+	void Ready();
+	void Reset();
+	void ResetSource();
+	void Schedule(shared_ptr<Event> &event);
 
-	//! Finish a single task of this pipeline
-	void FinishTask();
-	//! Finish executing this pipeline
-	void Finish();
+	//! Finalize this pipeline
+	void Finalize(Event &event);
 
 	string ToString() const;
 	void Print() const;
 
-	void SetRecursiveCTE(PhysicalOperator *op) {
-		this->recursive_cte = op;
-	}
-	PhysicalOperator *GetRecursiveCTE() {
-		return recursive_cte;
-	}
-	void ClearParents();
-
-	void IncrementTasks(idx_t amount) {
-		this->total_tasks += amount;
-	}
-
-	bool IsFinished() {
-		return finished;
-	}
 	//! Returns query progress
 	bool GetProgress(int &current_percentage);
 
-public:
-	//! The current threads working on the pipeline
-	atomic<idx_t> finished_tasks;
-	//! The maximum amount of threads that can work on the pipeline
-	atomic<idx_t> total_tasks;
+	//! Returns a list of all operators (including source and sink) involved in this pipeline
+	vector<PhysicalOperator *> GetOperators() const;
+
+	PhysicalOperator *GetSink() {
+		return sink;
+	}
 
 private:
-	//! The child from which to pull chunks
-	PhysicalOperator *child;
-	//! The global sink state
-	unique_ptr<GlobalOperatorState> sink_state;
+	//! Whether or not the pipeline has been readied
+	bool ready;
+	//! The source of this pipeline
+	PhysicalOperator *source;
+	//! The chain of intermediate operators
+	vector<PhysicalOperator *> operators;
 	//! The sink (i.e. destination) for data; this is e.g. a hash table to-be-built
-	PhysicalSink *sink;
+	PhysicalOperator *sink;
+
+	//! The global source state
+	unique_ptr<GlobalSourceState> source_state;
+
 	//! The parent pipelines (i.e. pipelines that are dependent on this pipeline to finish)
-	unordered_map<Pipeline *, weak_ptr<Pipeline>> parents;
+	vector<weak_ptr<Pipeline>> parents;
 	//! The dependencies of this pipeline
-	unordered_map<Pipeline *, weak_ptr<Pipeline>> dependencies;
-	//! The amount of completed dependencies (the pipeline can only be started after the dependencies have finished
-	//! executing)
-	atomic<idx_t> finished_dependencies;
-
-	//! The parallel operator (if any)
-	PhysicalOperator *parallel_node;
-	//! The parallel state (if any)
-	unique_ptr<ParallelState> parallel_state;
-
-	//! Whether or not the pipeline is finished executing
-	bool finished;
-	//! The recursive CTE node that this pipeline belongs to, and may be executed multiple times
-	PhysicalOperator *recursive_cte;
+	vector<weak_ptr<Pipeline>> dependencies;
 
 private:
-	bool GetProgress(ClientContext &context, PhysicalOperator *op, int &current_percentage);
-	void ScheduleSequentialTask();
-	bool LaunchScanTasks(PhysicalOperator *op, idx_t max_threads, unique_ptr<ParallelState> parallel_state);
-	bool ScheduleOperator(PhysicalOperator *op);
+	bool GetProgressInternal(ClientContext &context, PhysicalOperator *op, int &current_percentage);
+	void ScheduleSequentialTask(shared_ptr<Event> &event);
+	bool LaunchScanTasks(shared_ptr<Event> &event, idx_t max_threads);
+
+	bool ScheduleParallel(shared_ptr<Event> &event);
 };
 
 } // namespace duckdb
 
 
 
-#include <queue>
 
 namespace duckdb {
 class ClientContext;
 class DataChunk;
 class PhysicalOperator;
-class PhysicalOperatorState;
+class PipelineExecutor;
+class OperatorState;
 class ThreadContext;
 class Task;
 
+struct PipelineEventStack;
 struct ProducerToken;
 
+using event_map_t = unordered_map<const Pipeline *, PipelineEventStack>;
+
 class Executor {
 	friend class Pipeline;
 	friend class PipelineTask;
@@ -13010,8 +13352,10 @@ public:
 	ClientContext &context;
 
 public:
+	static Executor &Get(ClientContext &context);
+
 	void Initialize(PhysicalOperator *physical_plan);
-	void BuildPipelines(PhysicalOperator *op, Pipeline *parent);
+	void BuildPipelines(PhysicalOperator *op, Pipeline *current);
 
 	void Reset();
 
@@ -13020,8 +13364,15 @@ public:
 	unique_ptr<DataChunk> FetchChunk();
 
 	//! Push a new error
-	void PushError(const string &exception);
-	bool GetError(string &exception);
+	void PushError(ExceptionType type, const string &exception);
+	//! True if an error has been thrown
+	bool HasError();
+	//! Throw the exception that was pushed using PushError.
+	//! Should only be called if HasError returns true
+	void ThrowException();
+
+	//! Work on tasks for this specific executor, until there are no tasks remaining
+	void WorkOnTasks();
 
 	//! Flush a thread context into the client context
 	void Flush(ThreadContext &context);
@@ -13029,24 +13380,76 @@ public:
 	//! Returns the progress of the pipelines
 	bool GetPipelinesProgress(int &current_progress);
 
+	void CompletePipeline() {
+		completed_pipelines++;
+	}
+	ProducerToken &GetToken() {
+		return *producer;
+	}
+	void AddEvent(shared_ptr<Event> event);
+
+	void ReschedulePipelines(const vector<shared_ptr<Pipeline>> &pipelines, vector<shared_ptr<Event>> &events);
+
+private:
+	void ScheduleEvents();
+	void ScheduleEventsInternal(const vector<shared_ptr<Pipeline>> &pipelines,
+	                            unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> &child_pipelines,
+	                            vector<shared_ptr<Event>> &events, bool main_schedule = true);
+
+	void SchedulePipeline(const shared_ptr<Pipeline> &pipeline, event_map_t &event_map,
+	                      vector<shared_ptr<Event>> &events, bool complete_pipeline);
+	Pipeline *ScheduleUnionPipeline(const shared_ptr<Pipeline> &pipeline, const Pipeline *parent,
+	                                event_map_t &event_map, vector<shared_ptr<Event>> &events);
+	void ScheduleChildPipeline(Pipeline *parent, const shared_ptr<Pipeline> &pipeline, event_map_t &event_map,
+	                           vector<shared_ptr<Event>> &events);
+	void ExtractPipelines(shared_ptr<Pipeline> &pipeline, vector<shared_ptr<Pipeline>> &result);
+	bool NextExecutor();
+
+	void AddChildPipeline(Pipeline *current);
+
+	void VerifyPipeline(Pipeline &pipeline);
+	void VerifyPipelines();
+	void ThrowExceptionInternal();
+
 private:
 	PhysicalOperator *physical_plan;
-	unique_ptr<PhysicalOperatorState> physical_state;
 
 	mutex executor_lock;
 	//! The pipelines of the current query
 	vector<shared_ptr<Pipeline>> pipelines;
+	//! The root pipeline of the query
+	vector<shared_ptr<Pipeline>> root_pipelines;
+	//! The pipeline executor for the root pipeline
+	unique_ptr<PipelineExecutor> root_executor;
+	//! The current root pipeline index
+	idx_t root_pipeline_idx;
 	//! The producer of this query
 	unique_ptr<ProducerToken> producer;
 	//! Exceptions that occurred during the execution of the current query
-	vector<string> exceptions;
+	vector<pair<ExceptionType, string>> exceptions;
+	//! List of events
+	vector<shared_ptr<Event>> events;
 
 	//! The amount of completed pipelines of the query
 	atomic<idx_t> completed_pipelines;
 	//! The total amount of pipelines in the query
 	idx_t total_pipelines;
 
+	//! The adjacent union pipelines of each pipeline
+	//! Union pipelines have the same sink, but can be run concurrently along with this pipeline
+	unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> union_pipelines;
+	//! Child pipelines of this pipeline
+	//! Like union pipelines, child pipelines share the same sink
+	//! Unlike union pipelines, child pipelines should be run AFTER their dependencies are completed
+	//! i.e. they should be run after the dependencies are completed, but before finalize is called on the sink
+	unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> child_pipelines;
+	//! Dependencies of child pipelines
+	unordered_map<Pipeline *, vector<Pipeline *>> child_dependencies;
+
+	//! Duplicate eliminated join scan dependencies
 	unordered_map<PhysicalOperator *, Pipeline *> delim_join_dependencies;
+
+	//! Active recursive CTE node (if any)
 	PhysicalOperator *recursive_cte;
 };
 } // namespace duckdb
@@ -13065,7 +13468,7 @@ public:
 	//! Starts the thread
 	void Start();
 	//! Stops the thread
-	void Stop();
+	void Stop(bool success = true);
 	//! Gets current percentage
 	int GetCurrentPercentage();
 
@@ -13082,7 +13485,7 @@ private:
 	std::condition_variable c;
 	mutex m;
 #endif
-	idx_t show_progress_after;
+	atomic<idx_t> show_progress_after;
 	idx_t time_update_bar;
 	atomic<int> current_percentage;
 	atomic<bool> stop;
@@ -13168,6 +13571,75 @@ private:
 
 #include <random>
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/client_config.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/output_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class ExplainOutputType : uint8_t { ALL = 0, OPTIMIZED_ONLY = 1, PHYSICAL_ONLY = 2 };
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+class ClientContext;
+
+struct ClientConfig {
+	//! If the progress bar is enabled or not.
+	bool enable_progress_bar = false;
+	//! If the print of the progress bar is enabled
+	bool print_progress_bar = true;
+	//! The wait time before showing the progress bar
+	int wait_time = 2000;
+
+	// Whether or not aggressive query verification is enabled
+	bool query_verification_enabled = false;
+	//! Enable the running of optimizers
+	bool enable_optimizer = true;
+	//! Force parallelism of small tables, used for testing
+	bool verify_parallelism = false;
+	//! Force index join independent of table cardinality, used for testing
+	bool force_index_join = false;
+	//! Force out-of-core computation for operators that support it, used for testing
+	bool force_external = false;
+	//! Maximum bits allowed for using a perfect hash table (i.e. the perfect HT can hold up to 2^perfect_ht_threshold
+	//! elements)
+	idx_t perfect_ht_threshold = 12;
+
+	//! The explain output type used when none is specified (default: PHYSICAL_ONLY)
+	ExplainOutputType explain_output_type = ExplainOutputType::PHYSICAL_ONLY;
+
+	//! Generic options
+	case_insensitive_map_t<Value> set_variables;
+
+public:
+	static ClientConfig &GetConfig(ClientContext &context);
+};
+
+} // namespace duckdb
+
 
 namespace duckdb {
 class Appender;
@@ -13212,35 +13684,12 @@ public:
 
 	//! The Progress Bar
 	unique_ptr<ProgressBar> progress_bar;
-	//! If the progress bar is enabled or not.
-	bool enable_progress_bar = false;
-	//! If the print of the progress bar is enabled
-	bool print_progress_bar = true;
-	//! The wait time before showing the progress bar
-	int wait_time = 2000;
 
 	unique_ptr<SchemaCatalogEntry> temporary_objects;
 	unordered_map<string, shared_ptr<PreparedStatementData>> prepared_statements;
 
-	case_insensitive_map_t<Value> set_variables;
-
-	// Whether or not aggressive query verification is enabled
-	bool query_verification_enabled = false;
-	//! Enable the running of optimizers
-	bool enable_optimizer = true;
-	//! Force parallelism of small tables, used for testing
-	bool verify_parallelism = false;
-	//! Force index join independent of table cardinality, used for testing
-	bool force_index_join = false;
-	//! Force out-of-core computation for operators that support it, used for testing
-	bool force_external = false;
-	//! Maximum bits allowed for using a perfect hash table (i.e. the perfect HT can hold up to 2^perfect_ht_threshold
-	//! elements)
-	idx_t perfect_ht_threshold = 12;
 	//! The writer used to log queries (if logging is enabled)
 	unique_ptr<BufferedFileWriter> log_query_writer;
-	//! The explain output type used when none is specified (default: PHYSICAL_ONLY)
-	ExplainOutputType explain_output_type = ExplainOutputType::PHYSICAL_ONLY;
 	//! The random generator used by random(). Its seed value can be set by setseed().
 	std::mt19937 random_engine;
 
@@ -13248,6 +13697,9 @@ public:
 
 	unique_ptr<FileOpener> file_opener;
 
+	//! The client configuration
+	ClientConfig config;
+
 public:
 	DUCKDB_API Transaction &ActiveTransaction() {
 		return transaction.ActiveTransaction();