duckdb 0.3.2-dev3.0 → 0.3.2-dev300.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 "8ef7ee22c"
-#define DUCKDB_VERSION "0.3.2-dev3"
+#define DUCKDB_SOURCE_ID "c9a9053a2"
+#define DUCKDB_VERSION "0.3.2-dev300"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -72,6 +72,32 @@ using std::string;
 }
 
 
+
+#ifndef DUCKDB_API
+#ifdef _WIN32
+#if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
+#define DUCKDB_API __declspec(dllexport)
+#else
+#define DUCKDB_API __declspec(dllimport)
+#endif
+#else
+#define DUCKDB_API
+#endif
+#endif
+
+#ifndef DUCKDB_EXTENSION_API
+#ifdef _WIN32
+#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
+#define DUCKDB_EXTENSION_API __declspec(dllexport)
+#else
+#define DUCKDB_EXTENSION_API
+#endif
+#else
+#define DUCKDB_EXTENSION_API
+#endif
+#endif
+
+
 namespace duckdb {
 
 //! inline std directives that we use frequently
@@ -96,9 +122,6 @@ typedef int64_t row_t;
 //! The type used for hashes
 typedef uint64_t hash_t;
 
-//! The value used to signify an invalid index entry
-extern const idx_t INVALID_INDEX;
-
 //! data pointers
 typedef uint8_t data_t;
 typedef data_t *data_ptr_t;
@@ -124,6 +147,11 @@ extern const transaction_t NOT_DELETED_ID;
 
 extern const double PI;
 
+struct DConstants {
+	//! The value used to signify an invalid index entry
+	static constexpr const idx_t INVALID_INDEX = idx_t(-1);
+};
+
 struct Storage {
 	//! The size of a hard disk sector, only really needed for Direct IO
 	constexpr static int SECTOR_SIZE = 4096;
@@ -198,6 +226,12 @@ enum class ProfilerPrintFormat : uint8_t { NONE, QUERY_TREE, JSON, QUERY_TREE_OP
 #define suint64_t int64_t
 #endif
 
+#if defined(_WIN32) || defined(_WIN64)
+#define DUCKDB_WINDOWS
+#elif defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
+#define DUCKDB_POSIX
+#endif
+
 namespace duckdb {
 #if !defined(_MSC_VER) && (__cplusplus < 201402L)
 template <typename T, typename... Args>
@@ -546,28 +580,6 @@ using std::vector;
 
 
 
-#ifndef DUCKDB_API
-#ifdef _WIN32
-#if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
-#define DUCKDB_API __declspec(dllexport)
-#else
-#define DUCKDB_API __declspec(dllimport)
-#endif
-#else
-#define DUCKDB_API
-#endif
-#endif
-
-#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
-#ifdef _WIN32
-#define DUCKDB_EXTENSION_API __declspec(dllexport)
-#else
-#define DUCKDB_EXTENSION_API
-#endif
-#endif
-
-
-
 namespace duckdb {
 
 class Serializer;
@@ -925,42 +937,38 @@ 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_) {}
-
-	DUCKDB_API LogicalType(LogicalType &&other) :
-		id_(other.id_), physical_type_(other.physical_type_), type_info_(move(other.type_info_)) {}
+	DUCKDB_API LogicalType(const LogicalType &other);
+	DUCKDB_API LogicalType(LogicalType &&other) noexcept;
 
 	DUCKDB_API ~LogicalType();
 
-	LogicalTypeId id() const {
+	inline LogicalTypeId id() const {
 		return id_;
 	}
-	PhysicalType InternalType() const {
+	inline PhysicalType InternalType() const {
 		return physical_type_;
 	}
-	const ExtraTypeInfo *AuxInfo() const {
+	inline const ExtraTypeInfo *AuxInfo() const {
 		return type_info_.get();
 	}
 
 	// copy assignment
-	LogicalType& operator=(const LogicalType &other) {
+	inline LogicalType& operator=(const LogicalType &other) {
 		id_ = other.id_;
 		physical_type_ = other.physical_type_;
 		type_info_ = other.type_info_;
 		return *this;
 	}
 	// move assignment
-	LogicalType& operator=(LogicalType&& other) {
+	inline LogicalType& operator=(LogicalType&& other) {
 		id_ = other.id_;
 		physical_type_ = other.physical_type_;
 		type_info_ = move(other.type_info_);
 		return *this;
 	}
 
-	bool operator==(const LogicalType &rhs) const;
-	bool operator!=(const LogicalType &rhs) const {
+	DUCKDB_API bool operator==(const LogicalType &rhs) const;
+	inline bool operator!=(const LogicalType &rhs) const {
 		return !(*this == rhs);
 	}
 
@@ -990,34 +998,34 @@ private:
 	PhysicalType GetInternalType();
 
 public:
-	DUCKDB_API static const LogicalType SQLNULL;
-	DUCKDB_API static const LogicalType BOOLEAN;
-	DUCKDB_API static const LogicalType TINYINT;
-	DUCKDB_API static const LogicalType UTINYINT;
-	DUCKDB_API static const LogicalType SMALLINT;
-	DUCKDB_API static const LogicalType USMALLINT;
-	DUCKDB_API static const LogicalType INTEGER;
-	DUCKDB_API static const LogicalType UINTEGER;
-	DUCKDB_API static const LogicalType BIGINT;
-	DUCKDB_API static const LogicalType UBIGINT;
-	DUCKDB_API static const LogicalType FLOAT;
-	DUCKDB_API static const LogicalType DOUBLE;
-	DUCKDB_API static const LogicalType DATE;
-	DUCKDB_API static const LogicalType TIMESTAMP;
-	DUCKDB_API static const LogicalType TIMESTAMP_S;
-	DUCKDB_API static const LogicalType TIMESTAMP_MS;
-	DUCKDB_API static const LogicalType TIMESTAMP_NS;
-	DUCKDB_API static const LogicalType TIME;
-	DUCKDB_API static const LogicalType VARCHAR;
-	DUCKDB_API static const LogicalType ANY;
-	DUCKDB_API static const LogicalType BLOB;
-	DUCKDB_API static const LogicalType INTERVAL;
-	DUCKDB_API static const LogicalType HUGEINT;
-	DUCKDB_API static const LogicalType UUID;
-	DUCKDB_API static const LogicalType HASH;
-	DUCKDB_API static const LogicalType POINTER;
-	DUCKDB_API static const LogicalType TABLE;
-	DUCKDB_API static const LogicalType INVALID;
+	static constexpr const LogicalTypeId SQLNULL = LogicalTypeId::SQLNULL;
+	static constexpr const LogicalTypeId BOOLEAN = LogicalTypeId::BOOLEAN;
+	static constexpr const LogicalTypeId TINYINT = LogicalTypeId::TINYINT;
+	static constexpr const LogicalTypeId UTINYINT = LogicalTypeId::UTINYINT;
+	static constexpr const LogicalTypeId SMALLINT = LogicalTypeId::SMALLINT;
+	static constexpr const LogicalTypeId USMALLINT = LogicalTypeId::USMALLINT;
+	static constexpr const LogicalTypeId INTEGER = LogicalTypeId::INTEGER;
+	static constexpr const LogicalTypeId UINTEGER = LogicalTypeId::UINTEGER;
+	static constexpr const LogicalTypeId BIGINT = LogicalTypeId::BIGINT;
+	static constexpr const LogicalTypeId UBIGINT = LogicalTypeId::UBIGINT;
+	static constexpr const LogicalTypeId FLOAT = LogicalTypeId::FLOAT;
+	static constexpr const LogicalTypeId DOUBLE = LogicalTypeId::DOUBLE;
+	static constexpr const LogicalTypeId DATE = LogicalTypeId::DATE;
+	static constexpr const LogicalTypeId TIMESTAMP = LogicalTypeId::TIMESTAMP;
+	static constexpr const LogicalTypeId TIMESTAMP_S = LogicalTypeId::TIMESTAMP_SEC;
+	static constexpr const LogicalTypeId TIMESTAMP_MS = LogicalTypeId::TIMESTAMP_MS;
+	static constexpr const LogicalTypeId TIMESTAMP_NS = LogicalTypeId::TIMESTAMP_NS;
+	static constexpr const LogicalTypeId TIME = LogicalTypeId::TIME;
+	static constexpr const LogicalTypeId VARCHAR = LogicalTypeId::VARCHAR;
+	static constexpr const LogicalTypeId ANY = LogicalTypeId::ANY;
+	static constexpr const LogicalTypeId BLOB = LogicalTypeId::BLOB;
+	static constexpr const LogicalTypeId INTERVAL = LogicalTypeId::INTERVAL;
+	static constexpr const LogicalTypeId HUGEINT = LogicalTypeId::HUGEINT;
+	static constexpr const LogicalTypeId UUID = LogicalTypeId::UUID;
+	static constexpr const LogicalTypeId HASH = LogicalTypeId::HASH;
+	static constexpr const LogicalTypeId POINTER = LogicalTypeId::POINTER;
+	static constexpr const LogicalTypeId TABLE = LogicalTypeId::TABLE;
+	static constexpr const LogicalTypeId INVALID = LogicalTypeId::INVALID;
 
 	// 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
@@ -1158,15 +1166,9 @@ enum class ExceptionFormatValueType : uint8_t {
 };
 
 struct ExceptionFormatValue {
-	ExceptionFormatValue(double dbl_val) // NOLINT
-	    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE), dbl_val(dbl_val) {
-	}
-	ExceptionFormatValue(int64_t int_val) // NOLINT
-	    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER), int_val(int_val) {
-	}
-	ExceptionFormatValue(string str_val) // NOLINT
-	    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(move(str_val)) {
-	}
+	DUCKDB_API ExceptionFormatValue(double dbl_val);  // NOLINT
+	DUCKDB_API ExceptionFormatValue(int64_t int_val); // NOLINT
+	DUCKDB_API ExceptionFormatValue(string str_val);  // NOLINT
 
 	ExceptionFormatValueType type;
 
@@ -1183,19 +1185,19 @@ public:
 };
 
 template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value);
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value);
 template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(LogicalType value);
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(LogicalType value);
 template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value);
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value);
 template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(double value);
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(double value);
 template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value);
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value);
 template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(const char *value);
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(const char *value);
 template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value);
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value);
 
 } // namespace duckdb
 
@@ -1266,15 +1268,15 @@ enum class ExceptionType {
 
 class Exception : public std::exception {
 public:
-	explicit Exception(const string &msg);
-	Exception(ExceptionType exception_type, const string &message);
+	DUCKDB_API explicit Exception(const string &msg);
+	DUCKDB_API Exception(ExceptionType exception_type, const string &message);
 
 	ExceptionType type;
 
 public:
-	const char *what() const noexcept override;
+	DUCKDB_API const char *what() const noexcept override;
 
-	string ExceptionTypeToString(ExceptionType type);
+	DUCKDB_API string ExceptionTypeToString(ExceptionType type);
 
 	template <typename... Args>
 	static string ConstructMessage(const string &msg, Args... params) {
@@ -1282,7 +1284,7 @@ public:
 		return ConstructMessageRecursive(msg, values, params...);
 	}
 
-	static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values);
+	DUCKDB_API static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values);
 
 	template <class T, typename... Args>
 	static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values, T param,
@@ -1302,13 +1304,12 @@ private:
 //! Exceptions that are StandardExceptions do NOT invalidate the current transaction when thrown
 class StandardException : public Exception {
 public:
-	StandardException(ExceptionType exception_type, string message) : Exception(exception_type, message) {
-	}
+	DUCKDB_API StandardException(ExceptionType exception_type, const string &message);
 };
 
 class CatalogException : public StandardException {
 public:
-	explicit CatalogException(const string &msg);
+	DUCKDB_API explicit CatalogException(const string &msg);
 
 	template <typename... Args>
 	explicit CatalogException(const string &msg, Args... params) : CatalogException(ConstructMessage(msg, params...)) {
@@ -1317,7 +1318,7 @@ public:
 
 class ParserException : public StandardException {
 public:
-	explicit ParserException(const string &msg);
+	DUCKDB_API explicit ParserException(const string &msg);
 
 	template <typename... Args>
 	explicit ParserException(const string &msg, Args... params) : ParserException(ConstructMessage(msg, params...)) {
@@ -1326,7 +1327,7 @@ public:
 
 class BinderException : public StandardException {
 public:
-	explicit BinderException(const string &msg);
+	DUCKDB_API explicit BinderException(const string &msg);
 
 	template <typename... Args>
 	explicit BinderException(const string &msg, Args... params) : BinderException(ConstructMessage(msg, params...)) {
@@ -1335,7 +1336,7 @@ public:
 
 class ConversionException : public Exception {
 public:
-	explicit ConversionException(const string &msg);
+	DUCKDB_API explicit ConversionException(const string &msg);
 
 	template <typename... Args>
 	explicit ConversionException(const string &msg, Args... params)
@@ -1345,7 +1346,7 @@ public:
 
 class TransactionException : public Exception {
 public:
-	explicit TransactionException(const string &msg);
+	DUCKDB_API explicit TransactionException(const string &msg);
 
 	template <typename... Args>
 	explicit TransactionException(const string &msg, Args... params)
@@ -1355,7 +1356,7 @@ public:
 
 class NotImplementedException : public Exception {
 public:
-	explicit NotImplementedException(const string &msg);
+	DUCKDB_API explicit NotImplementedException(const string &msg);
 
 	template <typename... Args>
 	explicit NotImplementedException(const string &msg, Args... params)
@@ -1365,7 +1366,7 @@ public:
 
 class OutOfRangeException : public Exception {
 public:
-	explicit OutOfRangeException(const string &msg);
+	DUCKDB_API explicit OutOfRangeException(const string &msg);
 
 	template <typename... Args>
 	explicit OutOfRangeException(const string &msg, Args... params)
@@ -1375,7 +1376,7 @@ public:
 
 class OutOfMemoryException : public Exception {
 public:
-	explicit OutOfMemoryException(const string &msg);
+	DUCKDB_API explicit OutOfMemoryException(const string &msg);
 
 	template <typename... Args>
 	explicit OutOfMemoryException(const string &msg, Args... params)
@@ -1385,7 +1386,7 @@ public:
 
 class SyntaxException : public Exception {
 public:
-	explicit SyntaxException(const string &msg);
+	DUCKDB_API explicit SyntaxException(const string &msg);
 
 	template <typename... Args>
 	explicit SyntaxException(const string &msg, Args... params) : SyntaxException(ConstructMessage(msg, params...)) {
@@ -1394,7 +1395,7 @@ public:
 
 class ConstraintException : public Exception {
 public:
-	explicit ConstraintException(const string &msg);
+	DUCKDB_API explicit ConstraintException(const string &msg);
 
 	template <typename... Args>
 	explicit ConstraintException(const string &msg, Args... params)
@@ -1404,7 +1405,7 @@ public:
 
 class IOException : public Exception {
 public:
-	explicit IOException(const string &msg);
+	DUCKDB_API explicit IOException(const string &msg);
 
 	template <typename... Args>
 	explicit IOException(const string &msg, Args... params) : IOException(ConstructMessage(msg, params...)) {
@@ -1413,7 +1414,7 @@ public:
 
 class SerializationException : public Exception {
 public:
-	explicit SerializationException(const string &msg);
+	DUCKDB_API explicit SerializationException(const string &msg);
 
 	template <typename... Args>
 	explicit SerializationException(const string &msg, Args... params)
@@ -1423,7 +1424,7 @@ public:
 
 class SequenceException : public Exception {
 public:
-	explicit SequenceException(const string &msg);
+	DUCKDB_API explicit SequenceException(const string &msg);
 
 	template <typename... Args>
 	explicit SequenceException(const string &msg, Args... params)
@@ -1433,12 +1434,12 @@ public:
 
 class InterruptException : public Exception {
 public:
-	InterruptException();
+	DUCKDB_API InterruptException();
 };
 
 class FatalException : public Exception {
 public:
-	explicit FatalException(const string &msg);
+	DUCKDB_API explicit FatalException(const string &msg);
 
 	template <typename... Args>
 	explicit FatalException(const string &msg, Args... params) : FatalException(ConstructMessage(msg, params...)) {
@@ -1447,7 +1448,7 @@ public:
 
 class InternalException : public Exception {
 public:
-	explicit InternalException(const string &msg);
+	DUCKDB_API explicit InternalException(const string &msg);
 
 	template <typename... Args>
 	explicit InternalException(const string &msg, Args... params)
@@ -1457,7 +1458,7 @@ public:
 
 class InvalidInputException : public Exception {
 public:
-	explicit InvalidInputException(const string &msg);
+	DUCKDB_API explicit InvalidInputException(const string &msg);
 
 	template <typename... Args>
 	explicit InvalidInputException(const string &msg, Args... params)
@@ -1467,28 +1468,28 @@ public:
 
 class CastException : public Exception {
 public:
-	CastException(const PhysicalType origType, const PhysicalType newType);
-	CastException(const LogicalType &origType, const LogicalType &newType);
+	DUCKDB_API CastException(const PhysicalType origType, const PhysicalType newType);
+	DUCKDB_API CastException(const LogicalType &origType, const LogicalType &newType);
 };
 
 class InvalidTypeException : public Exception {
 public:
-	InvalidTypeException(PhysicalType type, const string &msg);
-	InvalidTypeException(const LogicalType &type, const string &msg);
+	DUCKDB_API InvalidTypeException(PhysicalType type, const string &msg);
+	DUCKDB_API InvalidTypeException(const LogicalType &type, const string &msg);
 };
 
 class TypeMismatchException : public Exception {
 public:
-	TypeMismatchException(const PhysicalType type_1, const PhysicalType type_2, const string &msg);
-	TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg);
+	DUCKDB_API TypeMismatchException(const PhysicalType type_1, const PhysicalType type_2, const string &msg);
+	DUCKDB_API TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg);
 };
 
 class ValueOutOfRangeException : public Exception {
 public:
-	ValueOutOfRangeException(const int64_t value, const PhysicalType origType, const PhysicalType newType);
-	ValueOutOfRangeException(const hugeint_t value, const PhysicalType origType, const PhysicalType newType);
-	ValueOutOfRangeException(const double value, const PhysicalType origType, const PhysicalType newType);
-	ValueOutOfRangeException(const PhysicalType varType, const idx_t length);
+	DUCKDB_API ValueOutOfRangeException(const int64_t value, const PhysicalType origType, const PhysicalType newType);
+	DUCKDB_API ValueOutOfRangeException(const hugeint_t value, const PhysicalType origType, const PhysicalType newType);
+	DUCKDB_API ValueOutOfRangeException(const double value, const PhysicalType origType, const PhysicalType newType);
+	DUCKDB_API ValueOutOfRangeException(const PhysicalType varType, const idx_t length);
 };
 
 } // namespace duckdb
@@ -1923,6 +1924,7 @@ public:
 	                   FileOpener *opener = nullptr);
 
 	FileSystem &fs;
+	string path;
 	unique_ptr<data_t[]> data;
 	idx_t offset;
 	idx_t total_written;
@@ -2224,14 +2226,14 @@ struct TemplatedValidityData {
 	static constexpr const V MAX_ENTRY = ~V(0);
 
 public:
-	explicit TemplatedValidityData(idx_t count) {
+	DUCKDB_API explicit TemplatedValidityData(idx_t count) {
 		auto entry_count = EntryCount(count);
 		owned_data = unique_ptr<V[]>(new V[entry_count]);
 		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
 			owned_data[entry_idx] = MAX_ENTRY;
 		}
 	}
-	TemplatedValidityData(const V *validity_mask, idx_t count) {
+	DUCKDB_API TemplatedValidityData(const V *validity_mask, idx_t count) {
 		D_ASSERT(validity_mask);
 		auto entry_count = EntryCount(count);
 		owned_data = unique_ptr<V[]>(new V[entry_count]);
@@ -2243,7 +2245,7 @@ public:
 	unique_ptr<V[]> owned_data;
 
 public:
-	static inline idx_t EntryCount(idx_t count) {
+	DUCKDB_API static inline idx_t EntryCount(idx_t count) {
 		return (count + (BITS_PER_VALUE - 1)) / BITS_PER_VALUE;
 	}
 };
@@ -2267,24 +2269,24 @@ public:
 	static constexpr const int STANDARD_MASK_SIZE = STANDARD_ENTRY_COUNT * sizeof(validity_t);
 
 public:
-	TemplatedValidityMask() : validity_mask(nullptr) {
+	DUCKDB_API TemplatedValidityMask() : validity_mask(nullptr) {
 	}
-	explicit TemplatedValidityMask(idx_t max_count) {
+	DUCKDB_API explicit TemplatedValidityMask(idx_t max_count) {
 		Initialize(max_count);
 	}
-	explicit TemplatedValidityMask(V *ptr) : validity_mask(ptr) {
+	DUCKDB_API explicit TemplatedValidityMask(V *ptr) : validity_mask(ptr) {
 	}
-	TemplatedValidityMask(const TemplatedValidityMask &original, idx_t count) {
+	DUCKDB_API TemplatedValidityMask(const TemplatedValidityMask &original, idx_t count) {
 		Copy(original, count);
 	}
 
-	static inline idx_t ValidityMaskSize(idx_t count = STANDARD_VECTOR_SIZE) {
+	DUCKDB_API static inline idx_t ValidityMaskSize(idx_t count = STANDARD_VECTOR_SIZE) {
 		return ValidityBuffer::EntryCount(count) * sizeof(V);
 	}
-	inline bool AllValid() const {
+	DUCKDB_API inline bool AllValid() const {
 		return !validity_mask;
 	}
-	bool CheckAllValid(idx_t count) const {
+	DUCKDB_API bool CheckAllValid(idx_t count) const {
 		if (AllValid()) {
 			return true;
 		}
@@ -2296,7 +2298,7 @@ public:
 		return valid_count == entry_count;
 	}
 
-	bool CheckAllValid(idx_t to, idx_t from) const {
+	DUCKDB_API bool CheckAllValid(idx_t to, idx_t from) const {
 		if (AllValid()) {
 			return true;
 		}
@@ -2308,40 +2310,40 @@ public:
 		return true;
 	}
 
-	inline V *GetData() const {
+	DUCKDB_API inline V *GetData() const {
 		return validity_mask;
 	}
-	void Reset() {
+	DUCKDB_API void Reset() {
 		validity_mask = nullptr;
 		validity_data.reset();
 	}
 
-	static inline idx_t EntryCount(idx_t count) {
+	DUCKDB_API static inline idx_t EntryCount(idx_t count) {
 		return ValidityBuffer::EntryCount(count);
 	}
-	inline V GetValidityEntry(idx_t entry_idx) const {
+	DUCKDB_API inline V GetValidityEntry(idx_t entry_idx) const {
 		if (!validity_mask) {
 			return ValidityBuffer::MAX_ENTRY;
 		}
 		return validity_mask[entry_idx];
 	}
-	static inline bool AllValid(V entry) {
+	DUCKDB_API static inline bool AllValid(V entry) {
 		return entry == ValidityBuffer::MAX_ENTRY;
 	}
-	static inline bool NoneValid(V entry) {
+	DUCKDB_API static inline bool NoneValid(V entry) {
 		return entry == 0;
 	}
-	static inline bool RowIsValid(V entry, idx_t idx_in_entry) {
+	DUCKDB_API static inline bool RowIsValid(V entry, idx_t idx_in_entry) {
 		return entry & (V(1) << V(idx_in_entry));
 	}
-	static inline void GetEntryIndex(idx_t row_idx, idx_t &entry_idx, idx_t &idx_in_entry) {
+	DUCKDB_API static inline void GetEntryIndex(idx_t row_idx, idx_t &entry_idx, idx_t &idx_in_entry) {
 		entry_idx = row_idx / BITS_PER_VALUE;
 		idx_in_entry = row_idx % BITS_PER_VALUE;
 	}
 
 	//! RowIsValidUnsafe should only be used if AllValid() is false: it achieves the same as RowIsValid but skips a
 	//! not-null check
-	inline bool RowIsValidUnsafe(idx_t row_idx) const {
+	DUCKDB_API inline bool RowIsValidUnsafe(idx_t row_idx) const {
 		D_ASSERT(validity_mask);
 		idx_t entry_idx, idx_in_entry;
 		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
@@ -2350,7 +2352,7 @@ public:
 	}
 
 	//! Returns true if a row is valid (i.e. not null), false otherwise
-	inline bool RowIsValid(idx_t row_idx) const {
+	DUCKDB_API inline bool RowIsValid(idx_t row_idx) const {
 		if (!validity_mask) {
 			return true;
 		}
@@ -2358,7 +2360,7 @@ public:
 	}
 
 	//! Same as SetValid, but skips a null check on validity_mask
-	inline void SetValidUnsafe(idx_t row_idx) {
+	DUCKDB_API inline void SetValidUnsafe(idx_t row_idx) {
 		D_ASSERT(validity_mask);
 		idx_t entry_idx, idx_in_entry;
 		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
@@ -2366,7 +2368,7 @@ public:
 	}
 
 	//! Marks the entry at the specified row index as valid (i.e. not-null)
-	inline void SetValid(idx_t row_idx) {
+	DUCKDB_API inline void SetValid(idx_t row_idx) {
 		if (!validity_mask) {
 			// if AllValid() we don't need to do anything
 			// the row is already valid
@@ -2376,20 +2378,20 @@ public:
 	}
 
 	//! Marks the bit at the specified entry as invalid (i.e. null)
-	inline void SetInvalidUnsafe(idx_t entry_idx, idx_t idx_in_entry) {
+	DUCKDB_API inline void SetInvalidUnsafe(idx_t entry_idx, idx_t idx_in_entry) {
 		D_ASSERT(validity_mask);
 		validity_mask[entry_idx] &= ~(V(1) << V(idx_in_entry));
 	}
 
 	//! Marks the bit at the specified row index as invalid (i.e. null)
-	inline void SetInvalidUnsafe(idx_t row_idx) {
+	DUCKDB_API inline void SetInvalidUnsafe(idx_t row_idx) {
 		idx_t entry_idx, idx_in_entry;
 		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
 		SetInvalidUnsafe(entry_idx, idx_in_entry);
 	}
 
 	//! Marks the entry at the specified row index as invalid (i.e. null)
-	inline void SetInvalid(idx_t row_idx) {
+	DUCKDB_API inline void SetInvalid(idx_t row_idx) {
 		if (!validity_mask) {
 			D_ASSERT(row_idx <= STANDARD_VECTOR_SIZE);
 			Initialize(STANDARD_VECTOR_SIZE);
@@ -2398,7 +2400,7 @@ public:
 	}
 
 	//! Mark the entry at the specified index as either valid or invalid (non-null or null)
-	inline void Set(idx_t row_idx, bool valid) {
+	DUCKDB_API inline void Set(idx_t row_idx, bool valid) {
 		if (valid) {
 			SetValid(row_idx);
 		} else {
@@ -2407,14 +2409,14 @@ public:
 	}
 
 	//! Ensure the validity mask is writable, allocating space if it is not initialized
-	inline void EnsureWritable() {
+	DUCKDB_API inline void EnsureWritable() {
 		if (!validity_mask) {
 			Initialize();
 		}
 	}
 
 	//! Marks "count" entries in the validity mask as invalid (null)
-	inline void SetAllInvalid(idx_t count) {
+	DUCKDB_API inline void SetAllInvalid(idx_t count) {
 		EnsureWritable();
 		for (idx_t i = 0; i < ValidityBuffer::EntryCount(count); i++) {
 			validity_mask[i] = 0;
@@ -2422,14 +2424,14 @@ public:
 	}
 
 	//! Marks "count" entries in the validity mask as valid (not null)
-	inline void SetAllValid(idx_t count) {
+	DUCKDB_API inline void SetAllValid(idx_t count) {
 		EnsureWritable();
 		for (idx_t i = 0; i < ValidityBuffer::EntryCount(count); i++) {
 			validity_mask[i] = ValidityBuffer::MAX_ENTRY;
 		}
 	}
 
-	inline bool IsMaskSet() const {
+	DUCKDB_API inline bool IsMaskSet() const {
 		if (validity_mask) {
 			return true;
 		}
@@ -2437,19 +2439,19 @@ public:
 	}
 
 public:
-	void Initialize(validity_t *validity) {
+	DUCKDB_API void Initialize(validity_t *validity) {
 		validity_data.reset();
 		validity_mask = validity;
 	}
-	void Initialize(const TemplatedValidityMask &other) {
+	DUCKDB_API void Initialize(const TemplatedValidityMask &other) {
 		validity_mask = other.validity_mask;
 		validity_data = other.validity_data;
 	}
-	void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
+	DUCKDB_API void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
 		validity_data = make_buffer<ValidityBuffer>(count);
 		validity_mask = validity_data->owned_data.get();
 	}
-	void Copy(const TemplatedValidityMask &other, idx_t count) {
+	DUCKDB_API void Copy(const TemplatedValidityMask &other, idx_t count) {
 		if (other.AllValid()) {
 			validity_data = nullptr;
 			validity_mask = nullptr;
@@ -2466,21 +2468,21 @@ protected:
 
 struct ValidityMask : public TemplatedValidityMask<validity_t> {
 public:
-	ValidityMask() : TemplatedValidityMask(nullptr) {
+	DUCKDB_API ValidityMask() : TemplatedValidityMask(nullptr) {
 	}
-	explicit ValidityMask(idx_t max_count) : TemplatedValidityMask(max_count) {
+	DUCKDB_API explicit ValidityMask(idx_t max_count) : TemplatedValidityMask(max_count) {
 	}
-	explicit ValidityMask(validity_t *ptr) : TemplatedValidityMask(ptr) {
+	DUCKDB_API explicit ValidityMask(validity_t *ptr) : TemplatedValidityMask(ptr) {
 	}
-	ValidityMask(const ValidityMask &original, idx_t count) : TemplatedValidityMask(original, count) {
+	DUCKDB_API ValidityMask(const ValidityMask &original, idx_t count) : TemplatedValidityMask(original, count) {
 	}
 
 public:
-	void Resize(idx_t old_size, idx_t new_size);
+	DUCKDB_API void Resize(idx_t old_size, idx_t new_size);
 
-	void Slice(const ValidityMask &other, idx_t offset);
-	void Combine(const ValidityMask &other, idx_t count);
-	string ToString(idx_t count) const;
+	DUCKDB_API void Slice(const ValidityMask &other, idx_t offset);
+	DUCKDB_API void Combine(const ValidityMask &other, idx_t count);
+	DUCKDB_API string ToString(idx_t count) const;
 };
 
 } // namespace duckdb
@@ -2512,25 +2514,25 @@ class Value {
 
 public:
 	//! Create an empty NULL value of the specified type
-	explicit Value(LogicalType type = LogicalType::SQLNULL);
+	DUCKDB_API explicit Value(LogicalType type = LogicalType::SQLNULL);
 	//! Create an INTEGER value
-	Value(int32_t val); // NOLINT: Allow implicit conversion from `int32_t`
+	DUCKDB_API Value(int32_t val); // NOLINT: Allow implicit conversion from `int32_t`
 	//! Create a BIGINT value
-	Value(int64_t val); // NOLINT: Allow implicit conversion from `int64_t`
+	DUCKDB_API Value(int64_t val); // NOLINT: Allow implicit conversion from `int64_t`
 	//! Create a FLOAT value
-	Value(float val); // NOLINT: Allow implicit conversion from `float`
+	DUCKDB_API Value(float val); // NOLINT: Allow implicit conversion from `float`
 	//! Create a DOUBLE value
-	Value(double val); // NOLINT: Allow implicit conversion from `double`
+	DUCKDB_API Value(double val); // NOLINT: Allow implicit conversion from `double`
 	//! Create a VARCHAR value
-	Value(const char *val); // NOLINT: Allow implicit conversion from `const char *`
+	DUCKDB_API Value(const char *val); // NOLINT: Allow implicit conversion from `const char *`
 	//! Create a NULL value
-	Value(std::nullptr_t val); // NOLINT: Allow implicit conversion from `nullptr_t`
+	DUCKDB_API Value(std::nullptr_t val); // NOLINT: Allow implicit conversion from `nullptr_t`
 	//! Create a VARCHAR value
-	Value(string_t val); // NOLINT: Allow implicit conversion from `string_t`
+	DUCKDB_API Value(string_t val); // NOLINT: Allow implicit conversion from `string_t`
 	//! Create a VARCHAR value
-	Value(string val); // NOLINT: Allow implicit conversion from `string`
+	DUCKDB_API Value(string val); // NOLINT: Allow implicit conversion from `string`
 
-	const LogicalType &type() const {
+	inline const LogicalType &type() const {
 		return type_;
 	}
 
@@ -2661,32 +2663,32 @@ public:
 	//===--------------------------------------------------------------------===//
 	// Numeric Operators
 	//===--------------------------------------------------------------------===//
-	Value operator+(const Value &rhs) const;
-	Value operator-(const Value &rhs) const;
-	Value operator*(const Value &rhs) const;
-	Value operator/(const Value &rhs) const;
-	Value operator%(const Value &rhs) const;
+	DUCKDB_API Value operator+(const Value &rhs) const;
+	DUCKDB_API Value operator-(const Value &rhs) const;
+	DUCKDB_API Value operator*(const Value &rhs) const;
+	DUCKDB_API Value operator/(const Value &rhs) const;
+	DUCKDB_API Value operator%(const Value &rhs) const;
 
 	//===--------------------------------------------------------------------===//
 	// Comparison Operators
 	//===--------------------------------------------------------------------===//
-	bool operator==(const Value &rhs) const;
-	bool operator!=(const Value &rhs) const;
-	bool operator<(const Value &rhs) const;
-	bool operator>(const Value &rhs) const;
-	bool operator<=(const Value &rhs) const;
-	bool operator>=(const Value &rhs) const;
-
-	bool operator==(const int64_t &rhs) const;
-	bool operator!=(const int64_t &rhs) const;
-	bool operator<(const int64_t &rhs) const;
-	bool operator>(const int64_t &rhs) const;
-	bool operator<=(const int64_t &rhs) const;
-	bool operator>=(const int64_t &rhs) const;
-
-	static bool FloatIsValid(float value);
-	static bool DoubleIsValid(double value);
-	static bool StringIsValid(const char *str, idx_t length);
+	DUCKDB_API bool operator==(const Value &rhs) const;
+	DUCKDB_API bool operator!=(const Value &rhs) const;
+	DUCKDB_API bool operator<(const Value &rhs) const;
+	DUCKDB_API bool operator>(const Value &rhs) const;
+	DUCKDB_API bool operator<=(const Value &rhs) const;
+	DUCKDB_API bool operator>=(const Value &rhs) const;
+
+	DUCKDB_API bool operator==(const int64_t &rhs) const;
+	DUCKDB_API bool operator!=(const int64_t &rhs) const;
+	DUCKDB_API bool operator<(const int64_t &rhs) const;
+	DUCKDB_API bool operator>(const int64_t &rhs) const;
+	DUCKDB_API bool operator<=(const int64_t &rhs) const;
+	DUCKDB_API bool operator>=(const int64_t &rhs) const;
+
+	DUCKDB_API static bool FloatIsValid(float value);
+	DUCKDB_API static bool DoubleIsValid(double value);
+	DUCKDB_API static bool StringIsValid(const char *str, idx_t length);
 	static bool StringIsValid(const string &str) {
 		return StringIsValid(str.c_str(), str.size());
 	}
@@ -2698,13 +2700,13 @@ public:
 
 	//! Returns true if the values are (approximately) equivalent. Note this is NOT the SQL equivalence. For this
 	//! function, NULL values are equivalent and floating point values that are close are equivalent.
-	static bool ValuesAreEqual(const Value &result_value, const Value &value);
+	DUCKDB_API static bool ValuesAreEqual(const Value &result_value, const Value &value);
 
 	friend std::ostream &operator<<(std::ostream &out, const Value &val) {
 		out << val.ToString();
 		return out;
 	}
-	void Print() const;
+	DUCKDB_API void Print() const;
 
 private:
 	//! The logical of the value
@@ -3283,69 +3285,69 @@ class Vector {
 
 public:
 	//! Create a vector that references the other vector
-	explicit Vector(Vector &other);
+	DUCKDB_API explicit Vector(Vector &other);
 	//! Create a vector that slices another vector
-	explicit Vector(Vector &other, const SelectionVector &sel, idx_t count);
+	DUCKDB_API explicit Vector(Vector &other, const SelectionVector &sel, idx_t count);
 	//! Create a vector that slices another vector starting from a specific offset
-	explicit Vector(Vector &other, idx_t offset);
+	DUCKDB_API explicit Vector(Vector &other, idx_t offset);
 	//! Create a vector of size one holding the passed on value
-	explicit Vector(const Value &value);
+	DUCKDB_API explicit Vector(const Value &value);
 	//! Create a vector of size tuple_count (non-standard)
-	explicit Vector(LogicalType type, idx_t capacity = STANDARD_VECTOR_SIZE);
+	DUCKDB_API explicit Vector(LogicalType type, idx_t capacity = STANDARD_VECTOR_SIZE);
 	//! Create an empty standard vector with a type, equivalent to calling Vector(type, true, false)
-	explicit Vector(const VectorCache &cache);
+	DUCKDB_API explicit Vector(const VectorCache &cache);
 	//! Create a non-owning vector that references the specified data
-	Vector(LogicalType type, data_ptr_t dataptr);
+	DUCKDB_API Vector(LogicalType type, data_ptr_t dataptr);
 	//! Create an owning vector that holds at most STANDARD_VECTOR_SIZE entries.
 	/*!
 	    Create a new vector
 	    If create_data is true, the vector will be an owning empty vector.
 	    If zero_data is true, the allocated data will be zero-initialized.
 	*/
-	Vector(LogicalType type, bool create_data, bool zero_data, idx_t capacity = STANDARD_VECTOR_SIZE);
+	DUCKDB_API Vector(LogicalType type, bool create_data, bool zero_data, idx_t capacity = STANDARD_VECTOR_SIZE);
 	// implicit copying of Vectors is not allowed
-	Vector(const Vector &) = delete;
+	DUCKDB_API Vector(const Vector &) = delete;
 	// but moving of vectors is allowed
-	Vector(Vector &&other) noexcept;
+	DUCKDB_API Vector(Vector &&other) noexcept;
 
 public:
 	//! Create a vector that references the specified value.
-	void Reference(const Value &value);
+	DUCKDB_API void Reference(const Value &value);
 	//! Causes this vector to reference the data held by the other vector.
 	//! The type of the "other" vector should match the type of this vector
-	void Reference(Vector &other);
+	DUCKDB_API void Reference(Vector &other);
 	//! Reinterpret the data of the other vector as the type of this vector
 	//! Note that this takes the data of the other vector as-is and places it in this vector
 	//! Without changing the type of this vector
-	void Reinterpret(Vector &other);
+	DUCKDB_API 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);
+	DUCKDB_API 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.
-	void ResetFromCache(const VectorCache &cache);
+	DUCKDB_API void ResetFromCache(const VectorCache &cache);
 
 	//! Creates a reference to a slice of the other vector
-	void Slice(Vector &other, idx_t offset);
+	DUCKDB_API void Slice(Vector &other, idx_t offset);
 	//! Creates a reference to a slice of the other vector
-	void Slice(Vector &other, const SelectionVector &sel, idx_t count);
+	DUCKDB_API void Slice(Vector &other, const SelectionVector &sel, idx_t count);
 	//! Turns the vector into a dictionary vector with the specified dictionary
-	void Slice(const SelectionVector &sel, idx_t count);
+	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count);
 	//! Slice the vector, keeping the result around in a cache or potentially using the cache instead of slicing
-	void Slice(const SelectionVector &sel, idx_t count, SelCache &cache);
+	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count, SelCache &cache);
 
 	//! Creates the data of this vector with the specified type. Any data that
 	//! is currently in the vector is destroyed.
-	void Initialize(bool zero_data = false, idx_t capacity = STANDARD_VECTOR_SIZE);
+	DUCKDB_API void Initialize(bool zero_data = false, idx_t capacity = STANDARD_VECTOR_SIZE);
 
 	//! Converts this Vector to a printable string representation
-	string ToString(idx_t count) const;
-	void Print(idx_t count);
+	DUCKDB_API string ToString(idx_t count) const;
+	DUCKDB_API void Print(idx_t count);
 
-	string ToString() const;
-	void Print();
+	DUCKDB_API string ToString() const;
+	DUCKDB_API void Print();
 
 	//! Flatten the vector, removing any compression and turning it into a FLAT_VECTOR
 	DUCKDB_API void Normalify(idx_t count);
@@ -3354,31 +3356,31 @@ public:
 	DUCKDB_API void Orrify(idx_t count, VectorData &data);
 
 	//! Turn the vector into a sequence vector
-	void Sequence(int64_t start, int64_t increment);
+	DUCKDB_API void Sequence(int64_t start, int64_t increment);
 
 	//! Verify that the Vector is in a consistent, not corrupt state. DEBUG
 	//! FUNCTION ONLY!
-	void Verify(idx_t count);
-	void Verify(const SelectionVector &sel, idx_t count);
-	void UTFVerify(idx_t count);
-	void UTFVerify(const SelectionVector &sel, idx_t count);
+	DUCKDB_API void Verify(idx_t count);
+	DUCKDB_API void Verify(const SelectionVector &sel, idx_t count);
+	DUCKDB_API void UTFVerify(idx_t count);
+	DUCKDB_API void UTFVerify(const SelectionVector &sel, idx_t count);
 
 	//! Returns the [index] element of the Vector as a Value.
-	Value GetValue(idx_t index) const;
+	DUCKDB_API Value GetValue(idx_t index) const;
 	//! Sets the [index] element of the Vector to the specified Value.
-	void SetValue(idx_t index, const Value &val);
+	DUCKDB_API void SetValue(idx_t index, const Value &val);
 
-	void SetAuxiliary(buffer_ptr<VectorBuffer> new_buffer) {
+	inline void SetAuxiliary(buffer_ptr<VectorBuffer> new_buffer) {
 		auxiliary = std::move(new_buffer);
 	};
 
 	//! This functions resizes the vector
-	void Resize(idx_t cur_size, idx_t new_size);
+	DUCKDB_API void Resize(idx_t cur_size, idx_t new_size);
 
 	//! Serializes a Vector to a stand-alone binary blob
-	void Serialize(idx_t count, Serializer &serializer);
+	DUCKDB_API void Serialize(idx_t count, Serializer &serializer);
 	//! Deserializes a blob back into a Vector
-	void Deserialize(idx_t count, Deserializer &source);
+	DUCKDB_API void Deserialize(idx_t count, Deserializer &source);
 
 	// Getters
 	inline VectorType GetVectorType() const {
@@ -3391,11 +3393,11 @@ public:
 		return data;
 	}
 
-	buffer_ptr<VectorBuffer> GetAuxiliary() {
+	inline buffer_ptr<VectorBuffer> GetAuxiliary() {
 		return auxiliary;
 	}
 
-	buffer_ptr<VectorBuffer> GetBuffer() {
+	inline buffer_ptr<VectorBuffer> GetBuffer() {
 		return buffer;
 	}
 
@@ -3646,8 +3648,8 @@ class VectorCache;
 class DataChunk {
 public:
 	//! Creates an empty DataChunk
-	DataChunk();
-	~DataChunk();
+	DUCKDB_API DataChunk();
+	DUCKDB_API ~DataChunk();
 
 	//! The vectors owned by the DataChunk.
 	vector<Vector> data;
@@ -3659,14 +3661,14 @@ public:
 	DUCKDB_API idx_t ColumnCount() const {
 		return data.size();
 	}
-	void SetCardinality(idx_t count_p) {
+	inline void SetCardinality(idx_t count_p) {
 		D_ASSERT(count_p <= capacity);
 		this->count = count_p;
 	}
-	void SetCardinality(const DataChunk &other) {
+	inline void SetCardinality(const DataChunk &other) {
 		this->count = other.size();
 	}
-	void SetCapacity(const DataChunk &other) {
+	inline void SetCapacity(const DataChunk &other) {
 		this->capacity = other.capacity;
 	}
 
@@ -3682,9 +3684,9 @@ public:
 	//! This will create one vector of the specified type for each LogicalType in the
 	//! types list. The vector will be referencing vector to the data owned by
 	//! the DataChunk.
-	void Initialize(const vector<LogicalType> &types);
+	DUCKDB_API void Initialize(const vector<LogicalType> &types);
 	//! Initializes an empty DataChunk with the given types. The vectors will *not* have any data allocated for them.
-	void InitializeEmpty(const vector<LogicalType> &types);
+	DUCKDB_API 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 and resize is not allowed.
@@ -5422,7 +5424,7 @@ public:
 	}
 
 	//! The location in the query (if any)
-	idx_t query_location = INVALID_INDEX;
+	idx_t query_location = DConstants::INVALID_INDEX;
 
 public:
 	bool IsAggregate() const override;
@@ -5491,11 +5493,8 @@ namespace duckdb {
 //! A column of a table.
 class ColumnDefinition {
 public:
-	ColumnDefinition(string name, LogicalType type) : name(name), type(type) {
-	}
-	ColumnDefinition(string name, LogicalType type, unique_ptr<ParsedExpression> default_value)
-	    : name(name), type(type), default_value(move(default_value)) {
-	}
+	DUCKDB_API ColumnDefinition(string name, LogicalType type);
+	DUCKDB_API ColumnDefinition(string name, LogicalType type, unique_ptr<ParsedExpression> default_value);
 
 	//! The name of the entry
 	string name;
@@ -5509,10 +5508,10 @@ public:
 	CompressionType compression_type = CompressionType::COMPRESSION_AUTO;
 
 public:
-	ColumnDefinition Copy() const;
+	DUCKDB_API ColumnDefinition Copy() const;
 
-	void Serialize(Serializer &serializer) const;
-	static ColumnDefinition Deserialize(Deserializer &source);
+	DUCKDB_API void Serialize(Serializer &serializer) const;
+	DUCKDB_API static ColumnDefinition Deserialize(Deserializer &source);
 };
 
 } // namespace duckdb
@@ -5538,24 +5537,11 @@ class TableFunction;
 struct PragmaInfo;
 
 struct FunctionData {
-	virtual ~FunctionData() {
-	}
+	DUCKDB_API virtual ~FunctionData();
 
-	virtual unique_ptr<FunctionData> Copy() {
-		throw InternalException("Unimplemented copy for FunctionData");
-	};
-	virtual bool Equals(FunctionData &other) {
-		return true;
-	}
-	static bool Equals(FunctionData *left, FunctionData *right) {
-		if (left == right) {
-			return true;
-		}
-		if (!left || !right) {
-			return false;
-		}
-		return left->Equals(*right);
-	}
+	DUCKDB_API virtual unique_ptr<FunctionData> Copy();
+	DUCKDB_API virtual bool Equals(FunctionData &other);
+	DUCKDB_API static bool Equals(FunctionData *left, FunctionData *right);
 };
 
 struct TableFunctionData : public FunctionData {
@@ -5571,10 +5557,8 @@ struct FunctionParameters {
 //! Function is the base class used for any type of function (scalar, aggregate or simple function)
 class Function {
 public:
-	explicit Function(string name) : name(name) {
-	}
-	virtual ~Function() {
-	}
+	DUCKDB_API explicit Function(string name);
+	DUCKDB_API virtual ~Function();
 
 	//! The name of the function
 	string name;
@@ -5590,35 +5574,33 @@ public:
 	                                      const unordered_map<string, LogicalType> &named_parameters);
 
 	//! Bind a scalar function from the set of functions and input arguments. Returns the index of the chosen function,
-	//! returns INVALID_INDEX and sets error if none could be found
-	static idx_t BindFunction(const string &name, vector<ScalarFunction> &functions, vector<LogicalType> &arguments,
-	                          string &error);
-	static idx_t BindFunction(const string &name, vector<ScalarFunction> &functions,
-	                          vector<unique_ptr<Expression>> &arguments, string &error);
+	//! returns DConstants::INVALID_INDEX and sets error if none could be found
+	DUCKDB_API static idx_t BindFunction(const string &name, vector<ScalarFunction> &functions,
+	                                     vector<LogicalType> &arguments, string &error);
+	DUCKDB_API static idx_t BindFunction(const string &name, vector<ScalarFunction> &functions,
+	                                     vector<unique_ptr<Expression>> &arguments, string &error);
 	//! Bind an aggregate function from the set of functions and input arguments. Returns the index of the chosen
-	//! function, returns INVALID_INDEX and sets error if none could be found
-	static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions, vector<LogicalType> &arguments,
-	                          string &error);
-	static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
-	                          vector<unique_ptr<Expression>> &arguments, string &error);
+	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
+	DUCKDB_API static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
+	                                     vector<LogicalType> &arguments, string &error);
+	DUCKDB_API static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
+	                                     vector<unique_ptr<Expression>> &arguments, string &error);
 	//! Bind a table function from the set of functions and input arguments. Returns the index of the chosen
-	//! function, returns INVALID_INDEX and sets error if none could be found
-	static idx_t BindFunction(const string &name, vector<TableFunction> &functions, vector<LogicalType> &arguments,
-	                          string &error);
-	static idx_t BindFunction(const string &name, vector<TableFunction> &functions,
-	                          vector<unique_ptr<Expression>> &arguments, string &error);
+	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
+	DUCKDB_API static idx_t BindFunction(const string &name, vector<TableFunction> &functions,
+	                                     vector<LogicalType> &arguments, string &error);
+	DUCKDB_API static idx_t BindFunction(const string &name, vector<TableFunction> &functions,
+	                                     vector<unique_ptr<Expression>> &arguments, string &error);
 	//! Bind a pragma function from the set of functions and input arguments
-	static idx_t BindFunction(const string &name, vector<PragmaFunction> &functions, PragmaInfo &info, string &error);
+	DUCKDB_API static idx_t BindFunction(const string &name, vector<PragmaFunction> &functions, PragmaInfo &info,
+	                                     string &error);
 };
 
 class SimpleFunction : public Function {
 public:
-	SimpleFunction(string name, vector<LogicalType> arguments,
-	               LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
-	    : Function(name), arguments(move(arguments)), varargs(varargs) {
-	}
-	~SimpleFunction() override {
-	}
+	DUCKDB_API SimpleFunction(string name, vector<LogicalType> arguments,
+	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
+	DUCKDB_API ~SimpleFunction() override;
 
 	//! The set of arguments of the function
 	vector<LogicalType> arguments;
@@ -5627,50 +5609,34 @@ public:
 	LogicalType varargs;
 
 public:
-	virtual string ToString() {
-		return Function::CallToString(name, arguments);
-	}
+	DUCKDB_API virtual string ToString();
 
-	bool HasVarArgs() const {
-		return varargs.id() != LogicalTypeId::INVALID;
-	}
+	DUCKDB_API bool HasVarArgs() const;
 };
 
 class SimpleNamedParameterFunction : public SimpleFunction {
 public:
-	SimpleNamedParameterFunction(string name, vector<LogicalType> arguments,
-	                             LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
-	    : SimpleFunction(name, move(arguments), varargs) {
-	}
-	~SimpleNamedParameterFunction() override {
-	}
+	DUCKDB_API SimpleNamedParameterFunction(string name, vector<LogicalType> arguments,
+	                                        LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
+	DUCKDB_API ~SimpleNamedParameterFunction() override;
 
 	//! The named parameters of the function
 	unordered_map<string, LogicalType> named_parameters;
 
 public:
-	string ToString() override {
-		return Function::CallToString(name, arguments, named_parameters);
-	}
-
-	bool HasNamedParameters() {
-		return named_parameters.size() != 0;
-	}
+	DUCKDB_API string ToString() override;
+	DUCKDB_API bool HasNamedParameters();
 
-	void EvaluateInputParameters(vector<LogicalType> &arguments, vector<Value> &parameters,
-	                             unordered_map<string, Value> &named_parameters,
-	                             vector<unique_ptr<ParsedExpression>> &children);
+	DUCKDB_API void EvaluateInputParameters(vector<LogicalType> &arguments, vector<Value> &parameters,
+	                                        unordered_map<string, Value> &named_parameters,
+	                                        vector<unique_ptr<ParsedExpression>> &children);
 };
 
 class BaseScalarFunction : public SimpleFunction {
 public:
-	BaseScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type, bool has_side_effects,
-	                   LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
-	    : SimpleFunction(move(name), move(arguments), move(varargs)), return_type(return_type),
-	      has_side_effects(has_side_effects) {
-	}
-	~BaseScalarFunction() override {
-	}
+	DUCKDB_API BaseScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
+	                              bool has_side_effects, LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
+	DUCKDB_API ~BaseScalarFunction() override;
 
 	//! Return type of the function
 	LogicalType return_type;
@@ -5679,14 +5645,12 @@ public:
 	bool has_side_effects;
 
 public:
-	hash_t Hash() const;
+	DUCKDB_API hash_t Hash() const;
 
 	//! Cast a set of expressions to the arguments of this function
-	void CastToFunctionArguments(vector<unique_ptr<Expression>> &children);
+	DUCKDB_API void CastToFunctionArguments(vector<unique_ptr<Expression>> &children);
 
-	string ToString() override {
-		return Function::CallToString(name, arguments, return_type);
-	}
+	DUCKDB_API string ToString() override;
 };
 
 class BuiltinFunctions {
@@ -6014,8 +5978,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;
@@ -6066,6 +6031,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);
@@ -6401,23 +6372,17 @@ typedef void (*dependency_function_t)(BoundFunctionExpression &expr, unordered_s
 
 class ScalarFunction : public BaseScalarFunction {
 public:
-	ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
-	               bool has_side_effects = false, bind_scalar_function_t bind = nullptr,
-	               dependency_function_t dependency = nullptr, function_statistics_t statistics = nullptr,
-	               init_local_state_t init_local_state = nullptr,
-	               LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
-	    : BaseScalarFunction(name, arguments, return_type, has_side_effects, varargs), function(function), bind(bind),
-	      init_local_state(init_local_state), dependency(dependency), statistics(statistics) {
-	}
+	DUCKDB_API ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
+	                          scalar_function_t function, bool has_side_effects = false,
+	                          bind_scalar_function_t bind = nullptr, dependency_function_t dependency = nullptr,
+	                          function_statistics_t statistics = nullptr, init_local_state_t init_local_state = nullptr,
+	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
 
-	ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
-	               bool has_side_effects = false, bind_scalar_function_t bind = nullptr,
-	               dependency_function_t dependency = nullptr, function_statistics_t statistics = nullptr,
-	               init_local_state_t init_local_state = nullptr,
-	               LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
-	    : ScalarFunction(string(), arguments, return_type, function, has_side_effects, bind, dependency, statistics,
-	                     init_local_state, varargs) {
-	}
+	DUCKDB_API ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
+	                          bool has_side_effects = false, bind_scalar_function_t bind = nullptr,
+	                          dependency_function_t dependency = nullptr, function_statistics_t statistics = nullptr,
+	                          init_local_state_t init_local_state = nullptr,
+	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
 
 	//! The main scalar function to execute
 	scalar_function_t function;
@@ -6430,73 +6395,30 @@ public:
 	//! The statistics propagation function (if any)
 	function_statistics_t statistics;
 
-	static unique_ptr<BoundFunctionExpression> BindScalarFunction(ClientContext &context, const string &schema,
-	                                                              const string &name,
-	                                                              vector<unique_ptr<Expression>> children,
-	                                                              string &error, bool is_operator = false);
-	static unique_ptr<BoundFunctionExpression> BindScalarFunction(ClientContext &context,
-	                                                              ScalarFunctionCatalogEntry &function,
-	                                                              vector<unique_ptr<Expression>> children,
-	                                                              string &error, bool is_operator = false);
+	DUCKDB_API static unique_ptr<BoundFunctionExpression> BindScalarFunction(ClientContext &context,
+	                                                                         const string &schema, const string &name,
+	                                                                         vector<unique_ptr<Expression>> children,
+	                                                                         string &error, bool is_operator = false);
+	DUCKDB_API static unique_ptr<BoundFunctionExpression> BindScalarFunction(ClientContext &context,
+	                                                                         ScalarFunctionCatalogEntry &function,
+	                                                                         vector<unique_ptr<Expression>> children,
+	                                                                         string &error, bool is_operator = false);
 
-	static unique_ptr<BoundFunctionExpression> BindScalarFunction(ClientContext &context, ScalarFunction bound_function,
-	                                                              vector<unique_ptr<Expression>> children,
-	                                                              bool is_operator = false);
+	DUCKDB_API static unique_ptr<BoundFunctionExpression> BindScalarFunction(ClientContext &context,
+	                                                                         ScalarFunction bound_function,
+	                                                                         vector<unique_ptr<Expression>> children,
+	                                                                         bool is_operator = false);
 
-	bool operator==(const ScalarFunction &rhs) const {
-		return CompareScalarFunctionT(rhs.function) && bind == rhs.bind && dependency == rhs.dependency &&
-		       statistics == rhs.statistics;
-	}
-	bool operator!=(const ScalarFunction &rhs) const {
-		return !(*this == rhs);
-	}
+	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
+	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;
 
-	bool Equal(const ScalarFunction &rhs) const {
-		// number of types
-		if (this->arguments.size() != rhs.arguments.size()) {
-			return false;
-		}
-		// argument types
-		for (idx_t i = 0; i < this->arguments.size(); ++i) {
-			if (this->arguments[i] != rhs.arguments[i]) {
-				return false;
-			}
-		}
-		// return type
-		if (this->return_type != rhs.return_type) {
-			return false;
-		}
-		// varargs
-		if (this->varargs != rhs.varargs) {
-			return false;
-		}
-
-		return true; // they are equal
-	}
+	DUCKDB_API bool Equal(const ScalarFunction &rhs) const;
 
 private:
-	bool CompareScalarFunctionT(const scalar_function_t other) const {
-		typedef void(scalar_function_ptr_t)(DataChunk &, ExpressionState &, Vector &);
-
-		auto func_ptr = (scalar_function_ptr_t **)function.template target<scalar_function_ptr_t *>();
-		auto other_ptr = (scalar_function_ptr_t **)other.template target<scalar_function_ptr_t *>();
-
-		// Case the functions were created from lambdas the target will return a nullptr
-		if (!func_ptr && !other_ptr) {
-			return true;
-		}
-		if (func_ptr == nullptr || other_ptr == nullptr) {
-			// scalar_function_t (std::functions) from lambdas cannot be compared
-			return false;
-		}
-		return ((size_t)*func_ptr == (size_t)*other_ptr);
-	}
+	bool CompareScalarFunctionT(const scalar_function_t &other) const;
 
 public:
-	static void NopFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-		D_ASSERT(input.ColumnCount() >= 1);
-		result.Reference(input.data[0]);
-	}
+	DUCKDB_API static void NopFunction(DataChunk &input, ExpressionState &state, Vector &result);
 
 	template <class TA, class TR, class OP>
 	static void UnaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
@@ -6947,12 +6869,12 @@ public:
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
 	static void UnaryWindow(Vector &input, FunctionData *bind_data, data_ptr_t state, const FrameBounds &frame,
-	                        const FrameBounds &prev, Vector &result, idx_t rid) {
+	                        const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
 
-		auto idata = FlatVector::GetData<const INPUT_TYPE>(input) - MinValue(frame.first, prev.first);
+		auto idata = FlatVector::GetData<const INPUT_TYPE>(input) - bias;
 		const auto &ivalid = FlatVector::Validity(input);
 		OP::template Window<STATE, INPUT_TYPE, RESULT_TYPE>(idata, ivalid, bind_data, (STATE *)state, frame, prev,
-		                                                    result, rid);
+		                                                    result, rid, bias);
 	}
 
 	template <class STATE_TYPE, class OP>
@@ -7336,7 +7258,7 @@ class SQLStatement;
 
 class QueryErrorContext {
 public:
-	explicit QueryErrorContext(SQLStatement *statement_ = nullptr, idx_t query_location_ = INVALID_INDEX)
+	explicit QueryErrorContext(SQLStatement *statement_ = nullptr, idx_t query_location_ = DConstants::INVALID_INDEX)
 	    : statement(statement_), query_location(query_location_) {
 	}
 
@@ -7381,6 +7303,7 @@ struct CreateViewInfo;
 struct CreateSequenceInfo;
 struct CreateCollationInfo;
 struct CreateTypeInfo;
+struct CreateTableInfo;
 
 class ClientContext;
 class Transaction;
@@ -7403,7 +7326,7 @@ struct CatalogEntryLookup {
 	SchemaCatalogEntry *schema;
 	CatalogEntry *entry;
 
-	bool Found() const {
+	DUCKDB_API bool Found() const {
 		return entry;
 	}
 };
@@ -7417,11 +7340,11 @@ struct SimilarCatalogEntry {
 	//! The schema of the entry.
 	SchemaCatalogEntry *schema;
 
-	bool Found() const {
+	DUCKDB_API bool Found() const {
 		return !name.empty();
 	}
 
-	string GetQualifiedName() const;
+	DUCKDB_API string GetQualifiedName() const;
 };
 
 //! The Catalog object represents the catalog of the database.
@@ -7441,79 +7364,88 @@ public:
 
 public:
 	//! Get the ClientContext from the Catalog
-	static Catalog &GetCatalog(ClientContext &context);
-	static Catalog &GetCatalog(DatabaseInstance &db);
+	DUCKDB_API static Catalog &GetCatalog(ClientContext &context);
+	DUCKDB_API static Catalog &GetCatalog(DatabaseInstance &db);
 
-	DependencyManager &GetDependencyManager() {
+	DUCKDB_API DependencyManager &GetDependencyManager() {
 		return *dependency_manager;
 	}
 
 	//! Returns the current version of the catalog (incremented whenever anything changes, not stored between restarts)
-	idx_t GetCatalogVersion();
+	DUCKDB_API idx_t GetCatalogVersion();
 	//! Trigger a modification in the catalog, increasing the catalog version and returning the previous version
-	idx_t ModifyCatalog();
+	DUCKDB_API idx_t ModifyCatalog();
 
 	//! Creates a schema in the catalog.
-	CatalogEntry *CreateSchema(ClientContext &context, CreateSchemaInfo *info);
+	DUCKDB_API CatalogEntry *CreateSchema(ClientContext &context, CreateSchemaInfo *info);
 	//! Creates a table in the catalog.
-	CatalogEntry *CreateTable(ClientContext &context, BoundCreateTableInfo *info);
+	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, BoundCreateTableInfo *info);
+	//! Creates a table in the catalog.
+	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info);
 	//! Create a table function in the catalog
-	CatalogEntry *CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info);
+	DUCKDB_API CatalogEntry *CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info);
 	//! Create a copy function in the catalog
-	CatalogEntry *CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info);
+	DUCKDB_API CatalogEntry *CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info);
 	//! Create a pragma function in the catalog
-	CatalogEntry *CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info);
+	DUCKDB_API CatalogEntry *CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info);
 	//! Create a scalar or aggregate function in the catalog
-	CatalogEntry *CreateFunction(ClientContext &context, CreateFunctionInfo *info);
+	DUCKDB_API CatalogEntry *CreateFunction(ClientContext &context, CreateFunctionInfo *info);
 	//! Creates a table in the catalog.
-	CatalogEntry *CreateView(ClientContext &context, CreateViewInfo *info);
+	DUCKDB_API CatalogEntry *CreateView(ClientContext &context, CreateViewInfo *info);
 	//! Creates a table in the catalog.
-	CatalogEntry *CreateSequence(ClientContext &context, CreateSequenceInfo *info);
+	DUCKDB_API CatalogEntry *CreateSequence(ClientContext &context, CreateSequenceInfo *info);
 	//! Creates a Enum in the catalog.
-	CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
+	DUCKDB_API CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
 	//! Creates a collation in the catalog
-	CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
+	DUCKDB_API CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
 
 	//! Creates a table in the catalog.
-	CatalogEntry *CreateTable(ClientContext &context, SchemaCatalogEntry *schema, BoundCreateTableInfo *info);
+	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, SchemaCatalogEntry *schema,
+	                                     BoundCreateTableInfo *info);
 	//! Create a table function in the catalog
-	CatalogEntry *CreateTableFunction(ClientContext &context, SchemaCatalogEntry *schema,
-	                                  CreateTableFunctionInfo *info);
+	DUCKDB_API CatalogEntry *CreateTableFunction(ClientContext &context, SchemaCatalogEntry *schema,
+	                                             CreateTableFunctionInfo *info);
 	//! Create a copy function in the catalog
-	CatalogEntry *CreateCopyFunction(ClientContext &context, SchemaCatalogEntry *schema, CreateCopyFunctionInfo *info);
+	DUCKDB_API CatalogEntry *CreateCopyFunction(ClientContext &context, SchemaCatalogEntry *schema,
+	                                            CreateCopyFunctionInfo *info);
 	//! Create a pragma function in the catalog
-	CatalogEntry *CreatePragmaFunction(ClientContext &context, SchemaCatalogEntry *schema,
-	                                   CreatePragmaFunctionInfo *info);
+	DUCKDB_API CatalogEntry *CreatePragmaFunction(ClientContext &context, SchemaCatalogEntry *schema,
+	                                              CreatePragmaFunctionInfo *info);
 	//! Create a scalar or aggregate function in the catalog
-	CatalogEntry *CreateFunction(ClientContext &context, SchemaCatalogEntry *schema, CreateFunctionInfo *info);
+	DUCKDB_API CatalogEntry *CreateFunction(ClientContext &context, SchemaCatalogEntry *schema,
+	                                        CreateFunctionInfo *info);
 	//! Creates a table in the catalog.
-	CatalogEntry *CreateView(ClientContext &context, SchemaCatalogEntry *schema, CreateViewInfo *info);
+	DUCKDB_API CatalogEntry *CreateView(ClientContext &context, SchemaCatalogEntry *schema, CreateViewInfo *info);
 	//! Creates a table in the catalog.
-	CatalogEntry *CreateSequence(ClientContext &context, SchemaCatalogEntry *schema, CreateSequenceInfo *info);
+	DUCKDB_API CatalogEntry *CreateSequence(ClientContext &context, SchemaCatalogEntry *schema,
+	                                        CreateSequenceInfo *info);
 	//! Creates a enum in the catalog.
-	CatalogEntry *CreateType(ClientContext &context, SchemaCatalogEntry *schema, CreateTypeInfo *info);
+	DUCKDB_API CatalogEntry *CreateType(ClientContext &context, SchemaCatalogEntry *schema, CreateTypeInfo *info);
 	//! Creates a collation in the catalog
-	CatalogEntry *CreateCollation(ClientContext &context, SchemaCatalogEntry *schema, CreateCollationInfo *info);
+	DUCKDB_API CatalogEntry *CreateCollation(ClientContext &context, SchemaCatalogEntry *schema,
+	                                         CreateCollationInfo *info);
 
 	//! Drops an entry from the catalog
-	void DropEntry(ClientContext &context, DropInfo *info);
+	DUCKDB_API void DropEntry(ClientContext &context, DropInfo *info);
 
 	//! Returns the schema object with the specified name, or throws an exception if it does not exist
-	SchemaCatalogEntry *GetSchema(ClientContext &context, const string &name = DEFAULT_SCHEMA, bool if_exists = false,
-	                              QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API SchemaCatalogEntry *GetSchema(ClientContext &context, const string &name = DEFAULT_SCHEMA,
+	                                         bool if_exists = false,
+	                                         QueryErrorContext error_context = QueryErrorContext());
 	//! Scans all the schemas in the system one-by-one, invoking the callback for each entry
-	void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback);
+	DUCKDB_API void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback);
 	//! Gets the "schema.name" entry of the specified type, if if_exists=true returns nullptr if entry does not exist,
 	//! otherwise an exception is thrown
-	CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
-	                       bool if_exists = false, QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &schema,
+	                                  const string &name, bool if_exists = false,
+	                                  QueryErrorContext error_context = QueryErrorContext());
 
 	template <class T>
 	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
 	            QueryErrorContext error_context = QueryErrorContext());
 
 	//! Alter an existing entry in the catalog.
-	void Alter(ClientContext &context, AlterInfo *info);
+	DUCKDB_API void Alter(ClientContext &context, AlterInfo *info);
 
 private:
 	//! The catalog version, incremented whenever anything changes in the catalog
@@ -7537,26 +7469,30 @@ private:
 };
 
 template <>
-TableCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                     bool if_exists, QueryErrorContext error_context);
+DUCKDB_API TableCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                                bool if_exists, QueryErrorContext error_context);
 template <>
-SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                        bool if_exists, QueryErrorContext error_context);
+DUCKDB_API SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
+                                                   const string &name, bool if_exists, QueryErrorContext error_context);
 template <>
-TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                             bool if_exists, QueryErrorContext error_context);
+DUCKDB_API TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
+                                                        const string &name, bool if_exists,
+                                                        QueryErrorContext error_context);
 template <>
-CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                            bool if_exists, QueryErrorContext error_context);
+DUCKDB_API CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
+                                                       const string &name, bool if_exists,
+                                                       QueryErrorContext error_context);
 template <>
-PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                              bool if_exists, QueryErrorContext error_context);
+DUCKDB_API PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
+                                                         const string &name, bool if_exists,
+                                                         QueryErrorContext error_context);
 template <>
-AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                                 bool if_exists, QueryErrorContext error_context);
+DUCKDB_API AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
+                                                            const string &name, bool if_exists,
+                                                            QueryErrorContext error_context);
 template <>
-CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                       bool if_exists, QueryErrorContext error_context);
+DUCKDB_API CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                                  bool if_exists, QueryErrorContext error_context);
 
 } // namespace duckdb
 
@@ -7921,7 +7857,7 @@ struct ColumnBinding {
 	idx_t table_index;
 	idx_t column_index;
 
-	ColumnBinding() : table_index(INVALID_INDEX), column_index(INVALID_INDEX) {
+	ColumnBinding() : table_index(DConstants::INVALID_INDEX), column_index(DConstants::INVALID_INDEX) {
 	}
 	ColumnBinding(idx_t table, idx_t column) : table_index(table), column_index(column) {
 	}
@@ -7975,7 +7911,7 @@ public:
 
 	virtual string GetName() const;
 	virtual string ParamsToString() const;
-	virtual string ToString(idx_t depth = 0) const;
+	virtual string ToString() const;
 	void Print();
 	//! Debug method: verify that the integrity of expressions & child nodes are maintained
 	virtual void Verify();
@@ -8119,26 +8055,29 @@ typedef void (*aggregate_simple_update_t)(Vector inputs[], FunctionData *bind_da
 //! The type used for updating complex windowed aggregate functions (optional)
 typedef std::pair<idx_t, idx_t> FrameBounds;
 typedef void (*aggregate_window_t)(Vector inputs[], FunctionData *bind_data, idx_t input_count, data_ptr_t state,
-                                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t offset);
+                                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid,
+                                   idx_t bias);
 
 class AggregateFunction : public BaseScalarFunction {
 public:
-	AggregateFunction(const string &name, 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)
+	DUCKDB_API AggregateFunction(const string &name, 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)
 	    : BaseScalarFunction(name, arguments, return_type, false), state_size(state_size), initialize(initialize),
 	      update(update), combine(combine), finalize(finalize), simple_update(simple_update), window(window),
 	      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)
+	DUCKDB_API 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)
 	    : AggregateFunction(string(), arguments, return_type, state_size, initialize, update, combine, finalize,
 	                        simple_update, bind, destructor, statistics, window) {
 	}
@@ -8166,23 +8105,23 @@ public:
 	//! The statistics propagation function (may be null)
 	aggregate_statistics_t statistics;
 
-	bool operator==(const AggregateFunction &rhs) const {
+	DUCKDB_API bool operator==(const AggregateFunction &rhs) const {
 		return state_size == rhs.state_size && initialize == rhs.initialize && update == rhs.update &&
 		       combine == rhs.combine && finalize == rhs.finalize && window == rhs.window;
 	}
-	bool operator!=(const AggregateFunction &rhs) const {
+	DUCKDB_API bool operator!=(const AggregateFunction &rhs) const {
 		return !(*this == rhs);
 	}
 
-	static unique_ptr<BoundAggregateExpression>
+	DUCKDB_API static unique_ptr<BoundAggregateExpression>
 	BindAggregateFunction(ClientContext &context, AggregateFunction bound_function,
 	                      vector<unique_ptr<Expression>> children, unique_ptr<Expression> filter = nullptr,
 	                      bool is_distinct = false, unique_ptr<BoundOrderModifier> order_bys = nullptr);
 
-	static unique_ptr<FunctionData> BindSortedAggregate(AggregateFunction &bound_function,
-	                                                    vector<unique_ptr<Expression>> &children,
-	                                                    unique_ptr<FunctionData> bind_info,
-	                                                    unique_ptr<BoundOrderModifier> order_bys);
+	DUCKDB_API static unique_ptr<FunctionData> BindSortedAggregate(AggregateFunction &bound_function,
+	                                                               vector<unique_ptr<Expression>> &children,
+	                                                               unique_ptr<FunctionData> bind_info,
+	                                                               unique_ptr<BoundOrderModifier> order_bys);
 
 public:
 	template <class STATE, class RESULT_TYPE, class OP>
@@ -8261,10 +8200,10 @@ public:
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
 	static void UnaryWindow(Vector inputs[], FunctionData *bind_data, idx_t input_count, data_ptr_t state,
-	                        const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid) {
+	                        const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
 		D_ASSERT(input_count == 1);
 		AggregateExecutor::UnaryWindow<STATE, INPUT_TYPE, RESULT_TYPE, OP>(inputs[0], bind_data, state, frame, prev,
-		                                                                   result, rid);
+		                                                                   result, rid, bias);
 	}
 
 	template <class STATE, class A_TYPE, class B_TYPE, class OP>
@@ -9457,11 +9396,13 @@ namespace duckdb {
 class Printer {
 public:
 	//! Print the object to stderr
-	static void Print(const string &str);
+	DUCKDB_API static void Print(const string &str);
 	//! Prints Progress
-	static void PrintProgress(int percentage, const char *pbstr, int pbwidth);
+	DUCKDB_API static void PrintProgress(int percentage, const char *pbstr, int pbwidth);
 	//! Prints an empty line when progress bar is done
-	static void FinishProgressBarPrint(const char *pbstr, int pbwidth);
+	DUCKDB_API static void FinishProgressBarPrint(const char *pbstr, int pbwidth);
+	//! Whether or not we are printing to a terminal
+	DUCKDB_API static bool IsTerminal();
 };
 } // namespace duckdb
 
@@ -9823,16 +9764,16 @@ namespace duckdb {
  */
 class StringUtil {
 public:
-	static bool CharacterIsSpace(char c) {
+	DUCKDB_API static bool CharacterIsSpace(char c) {
 		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
 	}
-	static bool CharacterIsNewline(char c) {
+	DUCKDB_API static bool CharacterIsNewline(char c) {
 		return c == '\n' || c == '\r';
 	}
-	static bool CharacterIsDigit(char c) {
+	DUCKDB_API static bool CharacterIsDigit(char c) {
 		return c >= '0' && c <= '9';
 	}
-	static char CharacterToLower(char c) {
+	DUCKDB_API static char CharacterToLower(char c) {
 		if (c >= 'A' && c <= 'Z') {
 			return c - ('A' - 'a');
 		}
@@ -9840,25 +9781,25 @@ public:
 	}
 
 	//! Returns true if the needle string exists in the haystack
-	static bool Contains(const string &haystack, const string &needle);
+	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
 
 	//! Returns true if the target string starts with the given prefix
-	static bool StartsWith(string str, string prefix);
+	DUCKDB_API static bool StartsWith(string str, string prefix);
 
 	//! Returns true if the target string <b>ends</b> with the given suffix.
-	static bool EndsWith(const string &str, const string &suffix);
+	DUCKDB_API static bool EndsWith(const string &str, const string &suffix);
 
 	//! Repeat a string multiple times
-	static string Repeat(const string &str, const idx_t n);
+	DUCKDB_API static string Repeat(const string &str, const idx_t n);
 
 	//! Split the input string based on newline char
-	static vector<string> Split(const string &str, char delimiter);
+	DUCKDB_API static vector<string> Split(const string &str, char delimiter);
 
 	//! Split the input string allong a quote. Note that any escaping is NOT supported.
-	static vector<string> SplitWithQuote(const string &str, char delimiter = ',', char quote = '"');
+	DUCKDB_API static vector<string> SplitWithQuote(const string &str, char delimiter = ',', char quote = '"');
 
 	//! Join multiple strings into one string. Components are concatenated by the given separator
-	static string Join(const vector<string> &input, const string &separator);
+	DUCKDB_API static string Join(const vector<string> &input, const string &separator);
 
 	//! Join multiple items of container with given size, transformed to string
 	//! using function, into one string using the given separator
@@ -9882,13 +9823,13 @@ public:
 	}
 
 	//! Return a string that formats the give number of bytes
-	static string BytesToHumanReadableString(idx_t bytes);
+	DUCKDB_API static string BytesToHumanReadableString(idx_t bytes);
 
 	//! Convert a string to uppercase
-	static string Upper(const string &str);
+	DUCKDB_API static string Upper(const string &str);
 
 	//! Convert a string to lowercase
-	static string Lower(const string &str);
+	DUCKDB_API static string Lower(const string &str);
 
 	//! Format a string using printf semantics
 	template <typename... Args>
@@ -9897,30 +9838,38 @@ public:
 	}
 
 	//! Split the input string into a vector of strings based on the split string
-	static vector<string> Split(const string &input, const string &split);
+	DUCKDB_API static vector<string> Split(const string &input, const string &split);
 
 	//! Remove the whitespace char in the left end of the string
-	static void LTrim(string &str);
+	DUCKDB_API static void LTrim(string &str);
 	//! Remove the whitespace char in the right end of the string
-	static void RTrim(string &str);
+	DUCKDB_API static void RTrim(string &str);
 	//! Remove the whitespace char in the left and right end of the string
-	static void Trim(string &str);
+	DUCKDB_API static void Trim(string &str);
 
-	static string Replace(string source, const string &from, const string &to);
+	DUCKDB_API static string Replace(string source, const string &from, const string &to);
 
 	//! Get the levenshtein distance from two strings
-	static idx_t LevenshteinDistance(const string &s1, const string &s2);
+	DUCKDB_API static idx_t LevenshteinDistance(const string &s1, const string &s2);
 
 	//! Get the top-n strings (sorted by the given score distance) from a set of scores.
 	//! At least one entry is returned (if there is one).
 	//! Strings are only returned if they have a score less than the threshold.
-	static vector<string> TopNStrings(vector<std::pair<string, idx_t>> scores, idx_t n = 5, idx_t threshold = 5);
+	DUCKDB_API static vector<string> TopNStrings(vector<std::pair<string, idx_t>> scores, idx_t n = 5,
+	                                             idx_t threshold = 5);
 	//! Computes the levenshtein distance of each string in strings, and compares it to target, then returns TopNStrings
 	//! with the given params.
-	static vector<string> TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n = 5,
-	                                      idx_t threshold = 5);
-	static string CandidatesMessage(const vector<string> &candidates, const string &candidate = "Candidate bindings");
+	DUCKDB_API static vector<string> TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n = 5,
+	                                                 idx_t threshold = 5);
+	DUCKDB_API static string CandidatesMessage(const vector<string> &candidates,
+	                                           const string &candidate = "Candidate bindings");
+
+	//! Generate an error message in the form of "{message_prefix}: nearest_string, nearest_string2, ...
+	//! Equivalent to calling TopNLevenshtein followed by CandidatesMessage
+	DUCKDB_API static string CandidatesErrorMessage(const vector<string> &strings, const string &target,
+	                                                const string &message_prefix, idx_t n = 5);
 };
+
 } // namespace duckdb
 
 
@@ -10033,6 +9982,7 @@ enum class OptimizerType : uint32_t {
 };
 
 string OptimizerTypeToString(OptimizerType type);
+OptimizerType OptimizerTypeFromString(const string &str);
 
 } // namespace duckdb
 
@@ -10061,6 +10011,29 @@ enum class WindowAggregationMode : uint32_t {
 
 } // 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;
@@ -10068,6 +10041,7 @@ class TableFunctionRef;
 class CompressionFunction;
 
 struct CompressionFunctionSet;
+struct DBConfig;
 
 enum class AccessMode : uint8_t { UNDEFINED = 0, AUTOMATIC = 1, READ_ONLY = 2, READ_WRITE = 3 };
 
@@ -10078,25 +10052,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;
@@ -10136,8 +10116,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
@@ -10158,6 +10136,14 @@ public:
 	//! 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;
+
+	DUCKDB_API void AddExtensionOption(string name, string description, LogicalType parameter,
+	                                   set_option_callback_t function = nullptr);
+
 public:
 	DUCKDB_API static DBConfig &GetConfig(ClientContext &context);
 	DUCKDB_API static DBConfig &GetConfig(DatabaseInstance &db);
@@ -10203,8 +10189,10 @@ class DuckDB;
 //! The Extension class is the base class used to define extensions
 class Extension {
 public:
+	DUCKDB_API virtual ~Extension();
+
 	DUCKDB_API virtual void Load(DuckDB &db) = 0;
-	DUCKDB_API virtual ~Extension() = default;
+	DUCKDB_API virtual std::string Name() = 0;
 };
 
 } // namespace duckdb
@@ -10252,6 +10240,7 @@ private:
 	unique_ptr<TaskScheduler> scheduler;
 	unique_ptr<ObjectCache> object_cache;
 	unique_ptr<ConnectionManager> connection_manager;
+	unordered_set<std::string> loaded_extensions;
 };
 
 //! The database object. This object holds the catalog and all the
@@ -10260,6 +10249,8 @@ class DuckDB {
 public:
 	DUCKDB_API explicit DuckDB(const char *path = nullptr, DBConfig *config = nullptr);
 	DUCKDB_API explicit DuckDB(const string &path, DBConfig *config = nullptr);
+	DUCKDB_API explicit DuckDB(DatabaseInstance &instance);
+
 	DUCKDB_API ~DuckDB();
 
 	//! Reference to the actual database instance
@@ -10269,7 +10260,11 @@ public:
 	template <class T>
 	void LoadExtension() {
 		T extension;
+		if (ExtensionIsLoaded(extension.Name())) {
+			return;
+		}
 		extension.Load(*this);
+		SetExtensionLoaded(extension.Name());
 	}
 
 	DUCKDB_API FileSystem &GetFileSystem();
@@ -10277,16 +10272,39 @@ public:
 	DUCKDB_API idx_t NumberOfThreads();
 	DUCKDB_API static const char *SourceID();
 	DUCKDB_API static const char *LibraryVersion();
+	DUCKDB_API static string Platform();
+	DUCKDB_API bool ExtensionIsLoaded(const std::string &name);
+	DUCKDB_API void SetExtensionLoaded(const std::string &name);
 };
 
 } // namespace duckdb
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/loadable_extension.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 
 
 #ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
 #ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#ifndef _WINSOCKAPI_
+#define _WINSOCKAPI_
+#endif
 #include <windows.h>
+
+#undef CreateDirectory
+#undef MoveFile
+#undef RemoveDirectory
+
 #include <delayimp.h>
 
 extern "C" {
@@ -10294,7 +10312,7 @@ extern "C" {
 This is interesting: Windows would normally require a duckdb.dll being on the DLL search path when we load an extension
 using LoadLibrary(). However, there is likely no such dll, because DuckDB was statically linked, or is running as part
 of an R or Python module with a completely different name (that we don't know) or something of the sorts. Amazingly,
-Windows supports lazy-loading DLLs by linking them with /DELAYLOAD. Then a callback will be triggerd whenever we access
+Windows supports lazy-loading DLLs by linking them with /DELAYLOAD. Then a callback will be triggered whenever we access
 symbols in the extension. Since DuckDB is already running in the host process (hopefully), we can use
 GetModuleHandle(NULL) to return the current process so the symbols are looked for there. See here for another
 explanation of this crazy process:
@@ -10332,8 +10350,9 @@ ExternC const PfnDliHook __pfnDliFailureHook2 = duckdb_dllimport_delay_hook;
 
 
 
+#ifndef DUCKDB_API
 #ifdef _WIN32
-#ifdef DUCKDB_BUILD_LIBRARY
+#if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
 #define DUCKDB_API __declspec(dllexport)
 #else
 #define DUCKDB_API __declspec(dllimport)
@@ -10341,6 +10360,7 @@ ExternC const PfnDliHook __pfnDliFailureHook2 = duckdb_dllimport_delay_hook;
 #else
 #define DUCKDB_API
 #endif
+#endif
 
 #include <stdbool.h>
 #include <stdint.h>
@@ -11894,14 +11914,11 @@ class TableCatalogEntry;
 class Connection;
 
 //! The Appender class can be used to append elements to a table.
-class Appender {
+class BaseAppender {
+protected:
 	//! The amount of chunks that will be gathered in the chunk collection before flushing
 	static constexpr const idx_t FLUSH_COUNT = 100;
 
-	//! A reference to a database connection that created this appender
-	shared_ptr<ClientContext> context;
-	//! The table description (including column names)
-	unique_ptr<TableDescription> description;
 	//! The append types
 	vector<LogicalType> types;
 	//! The buffered data for the append
@@ -11912,9 +11929,9 @@ class Appender {
 	idx_t column = 0;
 
 public:
-	DUCKDB_API Appender(Connection &con, const string &schema_name, const string &table_name);
-	DUCKDB_API Appender(Connection &con, const string &table_name);
-	DUCKDB_API ~Appender();
+	DUCKDB_API BaseAppender();
+	DUCKDB_API BaseAppender(vector<LogicalType> types);
+	DUCKDB_API virtual ~BaseAppender();
 
 	//! Begins a new row append, after calling this the other AppendX() functions
 	//! should be called the correct amount of times. After that,
@@ -11950,7 +11967,9 @@ public:
 		return column;
 	}
 
-private:
+protected:
+	void Destructor();
+	virtual void FlushInternal(ChunkCollection &collection) = 0;
 	void InitializeChunk();
 	void FlushChunk();
 
@@ -11972,46 +11991,75 @@ private:
 	void AppendValue(const Value &value);
 };
 
+class Appender : public BaseAppender {
+	//! A reference to a database connection that created this appender
+	shared_ptr<ClientContext> context;
+	//! The table description (including column names)
+	unique_ptr<TableDescription> description;
+
+public:
+	DUCKDB_API Appender(Connection &con, const string &schema_name, const string &table_name);
+	DUCKDB_API Appender(Connection &con, const string &table_name);
+	DUCKDB_API ~Appender() override;
+
+protected:
+	void FlushInternal(ChunkCollection &collection) override;
+};
+
+class InternalAppender : public BaseAppender {
+	//! The client context
+	ClientContext &context;
+	//! The internal table entry to append to
+	TableCatalogEntry &table;
+
+public:
+	DUCKDB_API InternalAppender(ClientContext &context, TableCatalogEntry &table);
+	DUCKDB_API ~InternalAppender() override;
+
+protected:
+	void FlushInternal(ChunkCollection &collection) override;
+};
+
 template <>
-void DUCKDB_API Appender::Append(bool value);
+DUCKDB_API void BaseAppender::Append(bool value);
 template <>
-void DUCKDB_API Appender::Append(int8_t value);
+DUCKDB_API void BaseAppender::Append(int8_t value);
 template <>
-void DUCKDB_API Appender::Append(int16_t value);
+DUCKDB_API void BaseAppender::Append(int16_t value);
 template <>
-void DUCKDB_API Appender::Append(int32_t value);
+DUCKDB_API void BaseAppender::Append(int32_t value);
 template <>
-void DUCKDB_API Appender::Append(int64_t value);
+DUCKDB_API void BaseAppender::Append(int64_t value);
 template <>
-void DUCKDB_API Appender::Append(hugeint_t value);
+DUCKDB_API void BaseAppender::Append(hugeint_t value);
 template <>
-void DUCKDB_API Appender::Append(uint8_t value);
+DUCKDB_API void BaseAppender::Append(uint8_t value);
 template <>
-void DUCKDB_API Appender::Append(uint16_t value);
+DUCKDB_API void BaseAppender::Append(uint16_t value);
 template <>
-void DUCKDB_API Appender::Append(uint32_t value);
+DUCKDB_API void BaseAppender::Append(uint32_t value);
 template <>
-void DUCKDB_API Appender::Append(uint64_t value);
+DUCKDB_API void BaseAppender::Append(uint64_t value);
 template <>
-void DUCKDB_API Appender::Append(float value);
+DUCKDB_API void BaseAppender::Append(float value);
 template <>
-void DUCKDB_API Appender::Append(double value);
+DUCKDB_API void BaseAppender::Append(double value);
 template <>
-void DUCKDB_API Appender::Append(date_t value);
+DUCKDB_API void BaseAppender::Append(date_t value);
 template <>
-void DUCKDB_API Appender::Append(dtime_t value);
+DUCKDB_API void BaseAppender::Append(dtime_t value);
 template <>
-void DUCKDB_API Appender::Append(timestamp_t value);
+DUCKDB_API void BaseAppender::Append(timestamp_t value);
 template <>
-void DUCKDB_API Appender::Append(interval_t value);
+DUCKDB_API void BaseAppender::Append(interval_t value);
 template <>
-void DUCKDB_API Appender::Append(const char *value);
+DUCKDB_API void BaseAppender::Append(const char *value);
 template <>
-void DUCKDB_API Appender::Append(string_t value);
+DUCKDB_API void BaseAppender::Append(string_t value);
 template <>
-void DUCKDB_API Appender::Append(Value value);
+DUCKDB_API void BaseAppender::Append(Value value);
 template <>
-void DUCKDB_API Appender::Append(std::nullptr_t value);
+DUCKDB_API void BaseAppender::Append(std::nullptr_t value);
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -12175,22 +12223,21 @@ enum class ConstraintType : uint8_t {
 //! Constraint is the base class of any type of table constraint.
 class Constraint {
 public:
-	explicit Constraint(ConstraintType type) : type(type) {};
-	virtual ~Constraint() {
-	}
+	DUCKDB_API explicit Constraint(ConstraintType type);
+	DUCKDB_API virtual ~Constraint();
 
 	ConstraintType type;
 
 public:
-	virtual string ToString() const = 0;
-	void Print();
+	DUCKDB_API virtual string ToString() const = 0;
+	DUCKDB_API void Print();
 
-	virtual unique_ptr<Constraint> Copy() = 0;
+	DUCKDB_API virtual unique_ptr<Constraint> Copy() = 0;
 	//! Serializes a Constraint to a stand-alone binary blob
-	virtual void Serialize(Serializer &serializer);
+	DUCKDB_API 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);
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
 };
 } // namespace duckdb
 
@@ -12278,7 +12325,7 @@ public:
 
 	//! 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 true, returns DConstants::INVALID_INDEX
 	//! If if_exists is false, throws an exception
 	idx_t GetColumnIndex(string &name, bool if_exists = false);
 
@@ -12317,21 +12364,21 @@ class CatalogSet {
 	friend class DependencyManager;
 
 public:
-	explicit CatalogSet(Catalog &catalog, unique_ptr<DefaultGenerator> defaults = nullptr);
+	DUCKDB_API explicit CatalogSet(Catalog &catalog, unique_ptr<DefaultGenerator> defaults = nullptr);
 
 	//! Create an entry in the catalog set. Returns whether or not it was
 	//! successful.
-	bool CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-	                 unordered_set<CatalogEntry *> &dependencies);
+	DUCKDB_API bool CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
+	                            unordered_set<CatalogEntry *> &dependencies);
 
-	bool AlterEntry(ClientContext &context, const string &name, AlterInfo *alter_info);
+	DUCKDB_API bool AlterEntry(ClientContext &context, const string &name, AlterInfo *alter_info);
 
-	bool DropEntry(ClientContext &context, const string &name, bool cascade);
+	DUCKDB_API bool DropEntry(ClientContext &context, const string &name, bool cascade);
 
 	void CleanupEntry(CatalogEntry *catalog_entry);
 
 	//! Returns the entry with the specified name
-	CatalogEntry *GetEntry(ClientContext &context, const string &name);
+	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, const string &name);
 
 	//! Gets the entry that is most similar to the given name (i.e. smallest levenshtein distance), or empty string if
 	//! none is found. The returned pair consists of the entry name and the distance (smaller means closer).
@@ -12342,9 +12389,9 @@ public:
 	void Undo(CatalogEntry *entry);
 
 	//! Scan the catalog set, invoking the callback method for every committed entry
-	void Scan(const std::function<void(CatalogEntry *)> &callback);
+	DUCKDB_API void Scan(const std::function<void(CatalogEntry *)> &callback);
 	//! Scan the catalog set, invoking the callback method for every entry
-	void Scan(ClientContext &context, const std::function<void(CatalogEntry *)> &callback);
+	DUCKDB_API void Scan(ClientContext &context, const std::function<void(CatalogEntry *)> &callback);
 
 	template <class T>
 	vector<T *> GetEntries(ClientContext &context) {
@@ -12353,8 +12400,8 @@ public:
 		return result;
 	}
 
-	static bool HasConflict(ClientContext &context, transaction_t timestamp);
-	static bool UseTimestamp(ClientContext &context, transaction_t timestamp);
+	DUCKDB_API static bool HasConflict(ClientContext &context, transaction_t timestamp);
+	DUCKDB_API static bool UseTimestamp(ClientContext &context, transaction_t timestamp);
 
 	CatalogEntry *GetEntryFromIndex(idx_t index);
 	void UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp);
@@ -12505,7 +12552,6 @@ private:
 } // namespace duckdb
 
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -12521,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
@@ -12690,6 +12718,7 @@ enum class PhysicalOperatorType : uint8_t {
 	// Helpers
 	// -----------------------------
 	EXPLAIN,
+	EXPLAIN_ANALYZE,
 	EMPTY_RESULT,
 	EXECUTE,
 	PREPARE,
@@ -12948,14 +12977,13 @@ struct ParallelState;
 class TableFilterSet;
 
 struct FunctionOperatorData {
-	virtual ~FunctionOperatorData() {
-	}
+	DUCKDB_API virtual ~FunctionOperatorData();
 };
 
 struct TableFilterCollection {
+	DUCKDB_API explicit TableFilterCollection(TableFilterSet *table_filters);
+
 	TableFilterSet *table_filters;
-	explicit TableFilterCollection(TableFilterSet *table_filters) : table_filters(table_filters) {
-	}
 };
 
 typedef unique_ptr<FunctionData> (*table_function_bind_t)(ClientContext &context, vector<Value> &inputs,
@@ -13000,6 +13028,7 @@ typedef string (*table_function_to_string_t)(const FunctionData *bind_data);
 
 class TableFunction : public SimpleNamedParameterFunction {
 public:
+	DUCKDB_API
 	TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
 	              table_function_bind_t bind = nullptr, table_function_init_t init = nullptr,
 	              table_statistics_t statistics = nullptr, table_function_cleanup_t cleanup = nullptr,
@@ -13010,14 +13039,8 @@ public:
 	              table_function_parallel_t parallel_function = nullptr,
 	              table_function_init_parallel_t parallel_init = nullptr,
 	              table_function_parallel_state_next_t parallel_state_next = nullptr, bool projection_pushdown = false,
-	              bool filter_pushdown = false, table_function_progress_t query_progress = nullptr)
-	    : SimpleNamedParameterFunction(std::move(name), move(arguments)), bind(bind), init(init), function(function),
-	      statistics(statistics), cleanup(cleanup), dependency(dependency), cardinality(cardinality),
-	      pushdown_complex_filter(pushdown_complex_filter), to_string(to_string), max_threads(max_threads),
-	      init_parallel_state(init_parallel_state), parallel_function(parallel_function), parallel_init(parallel_init),
-	      parallel_state_next(parallel_state_next), table_scan_progress(query_progress),
-	      projection_pushdown(projection_pushdown), filter_pushdown(filter_pushdown) {
-	}
+	              bool filter_pushdown = false, table_function_progress_t query_progress = nullptr);
+	DUCKDB_API
 	TableFunction(const vector<LogicalType> &arguments, table_function_t function, table_function_bind_t bind = nullptr,
 	              table_function_init_t init = nullptr, table_statistics_t statistics = nullptr,
 	              table_function_cleanup_t cleanup = nullptr, table_function_dependency_t dependency = nullptr,
@@ -13028,13 +13051,8 @@ public:
 	              table_function_parallel_t parallel_function = nullptr,
 	              table_function_init_parallel_t parallel_init = nullptr,
 	              table_function_parallel_state_next_t parallel_state_next = nullptr, bool projection_pushdown = false,
-	              bool filter_pushdown = false, table_function_progress_t query_progress = nullptr)
-	    : TableFunction(string(), arguments, function, bind, init, statistics, cleanup, dependency, cardinality,
-	                    pushdown_complex_filter, to_string, max_threads, init_parallel_state, parallel_function,
-	                    parallel_init, parallel_state_next, projection_pushdown, filter_pushdown, query_progress) {
-	}
-	TableFunction() : SimpleNamedParameterFunction("", {}) {
-	}
+	              bool filter_pushdown = false, table_function_progress_t query_progress = nullptr);
+	DUCKDB_API TableFunction();
 
 	//! Bind function
 	//! This function is used for determining the return type of a table producing function and returning bind data
@@ -13082,10 +13100,6 @@ public:
 	//! Whether or not the table function supports filter pushdown. If not supported a filter will be added
 	//! that applies the table filter directly.
 	bool filter_pushdown;
-
-	string ToString() override {
-		return SimpleNamedParameterFunction::ToString();
-	}
 };
 
 } // namespace duckdb
@@ -13170,6 +13184,7 @@ namespace duckdb {
 struct ConcurrentQueue;
 struct QueueProducerToken;
 class ClientContext;
+class DatabaseInstance;
 class TaskScheduler;
 
 struct SchedulerThread;
@@ -13193,6 +13208,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
@@ -13437,7 +13453,7 @@ public:
 	//! Starts the thread
 	void Start();
 	//! Stops the thread
-	void Stop();
+	void Stop(bool success = true);
 	//! Gets current percentage
 	int GetCurrentPercentage();
 
@@ -13454,7 +13470,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;
@@ -13540,6 +13556,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;
@@ -13584,35 +13669,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;
 
@@ -13620,6 +13682,9 @@ public:
 
 	unique_ptr<FileOpener> file_opener;
 
+	//! The client configuration
+	ClientConfig config;
+
 public:
 	DUCKDB_API Transaction &ActiveTransaction() {
 		return transaction.ActiveTransaction();