duckdb 0.7.1-dev2.0 → 0.7.1-dev284.0

package/src/duckdb/src/function/table/read_csv.cpp

@@ -10,6 +10,7 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/main/extension_helper.hpp"
 
 #include <limits>
 
@@ -29,7 +30,7 @@ void ReadCSVData::InitializeFiles(ClientContext &context, const vector<string> &
 	for (auto &file_pattern : patterns) {
 		auto found_files = fs.Glob(file_pattern, context);
 		if (found_files.empty()) {
-			throw IOException("No files found that match the pattern \"%s\"", file_pattern);
+			throw FileSystem::MissingFileException(file_pattern, context);
 		}
 		files.insert(files.end(), found_files.begin(), found_files.end());
 	}
@@ -98,6 +99,17 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 			if (names.empty()) {
 				throw BinderException("read_csv requires at least a single column as input!");
 			}
+		} else if (loption == "column_names" || loption == "names") {
+			if (!options.name_list.empty()) {
+				throw BinderException("read_csv_auto column_names/names can only be supplied once");
+			}
+			if (kv.second.IsNull()) {
+				throw BinderException("read_csv_auto %s cannot be NULL", kv.first);
+			}
+			auto &children = ListValue::GetChildren(kv.second);
+			for (auto &child : children) {
+				options.name_list.push_back(StringValue::Get(child));
+			}
 		} else if (loption == "column_types" || loption == "types" || loption == "dtypes") {
 			auto &child_type = kv.second.type();
 			if (child_type.id() != LogicalTypeId::STRUCT && child_type.id() != LogicalTypeId::LIST) {
@@ -251,9 +263,6 @@ public:
 	    : file_handle(std::move(file_handle_p)), system_threads(system_threads_p), buffer_size(buffer_size_p),
 	      force_parallelism(force_parallelism_p) {
 		current_file_path = files_path_p[0];
-		for (idx_t i = 0; i < rows_to_skip; i++) {
-			file_handle->ReadLine();
-		}
 		estimated_linenr = rows_to_skip;
 		file_size = file_handle->FileSize();
 		first_file_size = file_size;
@@ -303,7 +312,7 @@ public:
 			progress = double(bytes_read) / double(file_size);
 		}
 		// now get the total percentage of files read
-		double percentage = double(file_index) / total_files;
+		double percentage = double(file_index - 1) / total_files;
 		percentage += (double(1) / double(total_files)) * progress;
 		return percentage * 100;
 	}
@@ -575,6 +584,7 @@ struct SingleThreadedCSVState : public GlobalTableFunctionState {
 		{
 			lock_guard<mutex> l(csv_lock);
 			if (initial_reader) {
+				total_size = initial_reader->file_handle ? initial_reader->file_handle->FileSize() : 0;
 				return std::move(initial_reader);
 			}
 			if (next_file >= total_files) {
@@ -963,6 +973,8 @@ TableFunction ReadCSVTableFunction::GetAutoFunction(bool list_parameter) {
 	read_csv_auto.named_parameters["column_types"] = LogicalType::ANY;
 	read_csv_auto.named_parameters["dtypes"] = LogicalType::ANY;
 	read_csv_auto.named_parameters["types"] = LogicalType::ANY;
+	read_csv_auto.named_parameters["names"] = LogicalType::LIST(LogicalType::VARCHAR);
+	read_csv_auto.named_parameters["column_names"] = LogicalType::LIST(LogicalType::VARCHAR);
 	return read_csv_auto;
 }
 

package/src/duckdb/src/function/table/table_scan.cpp

@@ -287,9 +287,12 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 	// behold
 	storage.info->indexes.Scan([&](Index &index) {
 		// first rewrite the index expression so the ColumnBindings align with the column bindings of the current table
+
 		if (index.unbound_expressions.size() > 1) {
+			// NOTE: index scans are not (yet) supported for compound index keys
 			return false;
 		}
+
 		auto index_expression = index.unbound_expressions[0]->Copy();
 		bool rewrite_possible = true;
 		RewriteIndexExpression(index, get, *index_expression, rewrite_possible);

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.1-dev2"
+#define DUCKDB_VERSION "0.7.1-dev284"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "0f5e1ec507"
+#define DUCKDB_SOURCE_ID "6b7362d2ca"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -29,6 +29,7 @@ struct CreateFunctionInfo;
 struct CreateViewInfo;
 struct CreateSequenceInfo;
 struct CreateCollationInfo;
+struct CreateIndexInfo;
 struct CreateTypeInfo;
 struct CreateTableInfo;
 struct DatabaseSize;
@@ -137,6 +138,9 @@ public:
 	//! Creates a collation in the catalog
 	DUCKDB_API CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info);
 	DUCKDB_API CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
+	//! Creates an index in the catalog
+	DUCKDB_API CatalogEntry *CreateIndex(CatalogTransaction transaction, CreateIndexInfo *info);
+	DUCKDB_API CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info);
 
 	//! Creates a table in the catalog.
 	DUCKDB_API CatalogEntry *CreateTable(CatalogTransaction transaction, SchemaCatalogEntry *schema,
@@ -153,7 +157,7 @@ public:
 	//! Create a scalar or aggregate function in the catalog
 	DUCKDB_API CatalogEntry *CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                        CreateFunctionInfo *info);
-	//! Creates a table in the catalog.
+	//! Creates a view in the catalog
 	DUCKDB_API CatalogEntry *CreateView(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                    CreateViewInfo *info);
 	//! Creates a table in the catalog.

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_index_entry.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/catalog/catalog_entry/dindex_catalog_entry.hpp
+// duckdb/catalog/catalog_entry/duck_index_entry.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp

@@ -34,7 +34,7 @@ public:
 
 public:
 	string ToSQL() override;
-	void Serialize(duckdb::MetaBlockWriter &serializer);
+	void Serialize(Serializer &serializer);
 	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &source, ClientContext &context);
 
 	virtual string GetSchemaName() = 0;

package/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp

@@ -79,6 +79,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_TRANSACTION = 134,
 	LOGICAL_CREATE_TYPE = 135,
 	LOGICAL_ATTACH = 136,
+	LOGICAL_DETACH = 137,
 
 	// -----------------------------
 	// Explain

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -87,6 +87,7 @@ enum class PhysicalOperatorType : uint8_t {
 	TRANSACTION,
 	CREATE_TYPE,
 	ATTACH,
+	DETACH,
 
 	// -----------------------------
 	// Helpers

package/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp

@@ -43,11 +43,12 @@ enum class StatementType : uint8_t {
 	RELATION_STATEMENT,
 	EXTENSION_STATEMENT,
 	LOGICAL_PLAN_STATEMENT,
-	ATTACH_STATEMENT
+	ATTACH_STATEMENT,
+	DETACH_STATEMENT
 
 };
 
-string StatementTypeToString(StatementType type);
+DUCKDB_API string StatementTypeToString(StatementType type);
 
 enum class StatementReturnType : uint8_t {
 	QUERY_RESULT, // the statement returns a query result (e.g. for display to the user)

package/src/duckdb/src/include/duckdb/common/enums/wal_type.hpp

@@ -41,6 +41,9 @@ enum class WALType : uint8_t {
 	CREATE_TABLE_MACRO = 21,
 	DROP_TABLE_MACRO = 22,
 
+	CREATE_INDEX = 23,
+	DROP_INDEX = 24,
+
 	// -----------------------------
 	// Data
 	// -----------------------------

package/src/duckdb/src/include/duckdb/common/exception.hpp

@@ -262,6 +262,16 @@ public:
 	}
 };
 
+class MissingExtensionException : public IOException {
+public:
+	DUCKDB_API explicit MissingExtensionException(const string &msg);
+
+	template <typename... Args>
+	explicit MissingExtensionException(const string &msg, Args... params)
+	    : IOException(ConstructMessage(msg, params...)) {
+	}
+};
+
 class SerializationException : public Exception {
 public:
 	DUCKDB_API explicit SerializationException(const string &msg);

package/src/duckdb/src/include/duckdb/common/file_system.hpp

@@ -201,6 +201,7 @@ public:
 
 	//! Whether or not a sub-system can handle a specific file path
 	DUCKDB_API virtual bool CanHandleFile(const string &fpath);
+	DUCKDB_API static IOException MissingFileException(const string &file_path, ClientContext &context);
 
 	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
 	DUCKDB_API virtual void Seek(FileHandle &handle, idx_t location);

package/src/duckdb/src/include/duckdb/common/hive_partitioning.hpp

@@ -52,7 +52,15 @@ struct HivePartitionKey {
 
 	struct Equality {
 		bool operator()(const HivePartitionKey &a, const HivePartitionKey &b) const {
-			return a.values == b.values;
+			if (a.values.size() != b.values.size()) {
+				return false;
+			}
+			for (idx_t i = 0; i < a.values.size(); i++) {
+				if (!Value::NotDistinctFrom(a.values[i], b.values[i])) {
+					return false;
+				}
+			}
+			return true;
 		}
 	};
 };

package/src/duckdb/src/include/duckdb/common/radix_partitioning.hpp

@@ -78,13 +78,13 @@ protected:
 		case 2:
 		case 3:
 		case 4:
-			return GetBufferSize(1);
+			return GetBufferSize(1 << 1);
 		case 5:
-			return GetBufferSize(2);
+			return GetBufferSize(1 << 2);
 		case 6:
-			return GetBufferSize(3);
+			return GetBufferSize(1 << 3);
 		default:
-			return GetBufferSize(4);
+			return GetBufferSize(1 << 4);
 		}
 	}
 	void InitializeAppendStateInternal(PartitionedColumnDataAppendState &state) const override;

package/src/duckdb/src/include/duckdb/common/types/timestamp.hpp

@@ -93,6 +93,8 @@ struct timestamp_ns_t : public timestamp_t {};  // NOLINT
 struct timestamp_ms_t : public timestamp_t {};  // NOLINT
 struct timestamp_sec_t : public timestamp_t {}; // NOLINT
 
+enum class TimestampCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_NON_UTC_TIMEZONE };
+
 //! The Timestamp class is a static class that holds helper functions for the Timestamp
 //! type.
 class Timestamp {
@@ -110,7 +112,7 @@ public:
 	//! If the tz is not empty, the result is still an instant, but the parts can be extracted and applied to the TZ
 	DUCKDB_API static bool TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset,
 	                                             string_t &tz);
-	DUCKDB_API static bool TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result);
+	DUCKDB_API static TimestampCastResult TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result);
 	DUCKDB_API static timestamp_t FromCString(const char *str, idx_t len);
 	//! Convert a date object to a string in the format "YYYY-MM-DD hh:mm:ss"
 	DUCKDB_API static string ToString(timestamp_t timestamp);
@@ -161,6 +163,8 @@ public:
 
 	DUCKDB_API static string ConversionError(const string &str);
 	DUCKDB_API static string ConversionError(string_t str);
+	DUCKDB_API static string UnsupportedTimezoneError(const string &str);
+	DUCKDB_API static string UnsupportedTimezoneError(string_t str);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/art.hpp

@@ -29,24 +29,21 @@ namespace duckdb {
 class ConflictManager;
 
 struct ARTIndexScanState : public IndexScanState {
-	ARTIndexScanState() : checked(false), result_index(0) {
-	}
 
+	//! Scan predicates (single predicate scan or range scan)
 	Value values[2];
+	//! Expressions of the scan predicates
 	ExpressionType expressions[2];
-	bool checked;
+	bool checked = false;
+	//! All scanned row IDs
 	vector<row_t> result_ids;
 	Iterator iterator;
-	//! Stores the current leaf
-	Leaf *cur_leaf = nullptr;
-	//! Offset to leaf
-	idx_t result_index = 0;
 };
 
 enum class VerifyExistenceType : uint8_t {
-	APPEND = 0,    // for purpose to append into table
-	APPEND_FK = 1, // for purpose to append into table has foreign key
-	DELETE_FK = 2  // for purpose to delete from table related to foreign key
+	APPEND = 0,    // appends to a table
+	APPEND_FK = 1, // appends to a table that has a foreign key
+	DELETE_FK = 2  // delete from a table that has a foreign key
 };
 
 class ART : public Index {
@@ -62,47 +59,44 @@ public:
 	Node *tree;
 
 public:
-	//! Initialize a scan on the index with the given expression and column ids
-	//! to fetch from the base table for a single predicate
+	//! Initialize a single predicate scan on the index with the given expression and column IDs
 	unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
 	                                                         ExpressionType expression_type) override;
-
-	//! Initialize a scan on the index with the given expression and column ids
-	//! to fetch from the base table for two predicates
+	//! Initialize a two predicate scan on the index with the given expression and column IDs
 	unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, const Value &low_value,
 	                                                       ExpressionType low_expression_type, const Value &high_value,
 	                                                       ExpressionType high_expression_type) override;
-
-	//! Perform a lookup on the index
+	//! Performs a lookup on the index, fetching up to max_count result IDs. Returns true if all row IDs were fetched,
+	//! and false otherwise
 	bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
 	          vector<row_t> &result_ids) override;
-	//! Append entries to the index
+
+	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held
 	bool Append(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
-	//! Verify that data can be appended to the index
+	//! Verify that data can be appended to the index without a constraint violation
 	void VerifyAppend(DataChunk &chunk) override;
-	//! Verify that data can be appended to the index
+	//! Verify that data can be appended to the index without a constraint violation using the conflict manager
 	void VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) override;
-	//! Verify that data can be appended to the index for foreign key constraint
-	void VerifyAppendForeignKey(DataChunk &chunk) override;
-	//! Verify that data can be delete from the index for foreign key constraint
-	void VerifyDeleteForeignKey(DataChunk &chunk) override;
-	//! Delete entries in the index
+	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
 	void Delete(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
-	//! Insert data into the index
+	//! Insert a chunk of entries into the index
 	bool Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override;
 
 	//! Construct an ART from a vector of sorted keys
 	bool ConstructFromSorted(idx_t count, vector<Key> &keys, Vector &row_identifiers);
 
-	//! Search Equal and fetches the row IDs
+	//! Search equal values and fetches the row IDs
 	bool SearchEqual(Key &key, idx_t max_count, vector<row_t> &result_ids);
-	//! Search Equal used for Joins that do not need to fetch data
+	//! Search equal values used for joins that do not need to fetch data
 	void SearchEqualJoinNoFetch(Key &key, idx_t &result_size);
-	//! Serialized the ART
+
+	//! Serializes the index and returns the pair of block_id offset positions
 	BlockPointer Serialize(duckdb::MetaBlockWriter &writer) override;
 
-	//! Merge two ARTs
+	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
+	//! index must also be locked during the merge
 	bool MergeIndexes(IndexLock &state, Index *other_index) override;
+
 	//! Generate ART keys for an input chunk
 	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<Key> &keys);
 
@@ -110,30 +104,32 @@ public:
 	string GenerateErrorKeyName(DataChunk &input, idx_t row);
 	//! Generate the matching error message for a constraint violation
 	string GenerateConstraintErrorMessage(VerifyExistenceType verify_type, const string &key_name);
+	//! Performs constraint checking for a chunk of input data
+	void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) override;
 
 	//! Returns the string representation of an ART
 	string ToString() override;
-	//! Verifies that the memory_size value of the ART matches its actual size
+	//! Verifies that the in-memory size value of the index matches its actual size
 	void Verify() override;
+	//! Increases the memory size by the difference between the old size and the current size
+	//! and performs verifications
+	void IncreaseAndVerifyMemorySize(idx_t old_memory_size) override;
 
 private:
-	//! Insert a row id into a leaf node
+	//! Insert a row ID into a leaf
 	bool InsertToLeaf(Leaf &leaf, row_t row_id);
-	//! Insert the leaf value into the tree
+	//! Insert a key into the tree
 	bool Insert(Node *&node, Key &key, idx_t depth, row_t row_id);
-
-	//! Erase element from leaf (if leaf has more than one value) or eliminate the leaf itself
+	//! Erase a key from the tree (if a leaf has more than one value) or erase the leaf itself
 	void Erase(Node *&node, Key &key, idx_t depth, row_t row_id);
-
-	//! Perform 'Lookup' for an entire chunk, marking which succeeded
-	void LookupValues(DataChunk &input, ConflictManager &conflict_manager) final override;
-
-	//! Find the node with a matching key, optimistic version
+	//! Find the node with a matching key, or return nullptr if not found
 	Leaf *Lookup(Node *node, Key &key, idx_t depth);
-
+	//! Returns all row IDs belonging to a key greater (or equal) than the search key
 	bool SearchGreater(ARTIndexScanState *state, Key &key, bool inclusive, idx_t max_count, vector<row_t> &result_ids);
+	//! Returns all row IDs belonging to a key less (or equal) than the upper_bound
 	bool SearchLess(ARTIndexScanState *state, Key &upper_bound, bool inclusive, idx_t max_count,
 	                vector<row_t> &result_ids);
+	//! Returns all row IDs belonging to a key within the range of lower_bound and upper_bound
 	bool SearchCloseRange(ARTIndexScanState *state, Key &lower_bound, Key &upper_bound, bool left_inclusive,
 	                      bool right_inclusive, idx_t max_count, vector<row_t> &result_ids);
 };

package/src/duckdb/src/include/duckdb/execution/index/art/art_key.hpp

@@ -28,24 +28,24 @@ public:
 
 public:
 	template <class T>
-	static inline Key CreateKey(ArenaAllocator &allocator, T element) {
+	static inline Key CreateKey(ArenaAllocator &allocator, const LogicalType &type, T element) {
 		auto data = Key::CreateData<T>(allocator, element);
 		return Key(data, sizeof(element));
 	}
 
 	template <class T>
-	static inline Key CreateKey(ArenaAllocator &allocator, const Value &element) {
-		return CreateKey(allocator, element.GetValueUnsafe<T>());
+	static inline Key CreateKey(ArenaAllocator &allocator, const LogicalType &type, const Value &element) {
+		return CreateKey(allocator, type, element.GetValueUnsafe<T>());
 	}
 
 	template <class T>
-	static inline void CreateKey(ArenaAllocator &allocator, Key &key, T element) {
+	static inline void CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, T element) {
 		key.data = Key::CreateData<T>(allocator, element);
 		key.len = sizeof(element);
 	}
 
 	template <class T>
-	static inline void CreateKey(ArenaAllocator &allocator, Key &key, const Value element) {
+	static inline void CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, const Value element) {
 		key.data = Key::CreateData<T>(allocator, element.GetValueUnsafe<T>());
 		key.len = sizeof(element);
 	}
@@ -76,12 +76,9 @@ private:
 };
 
 template <>
-Key Key::CreateKey(ArenaAllocator &allocator, string_t value);
+Key Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, string_t value);
 template <>
-Key Key::CreateKey(ArenaAllocator &allocator, const char *value);
+Key Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, const char *value);
 template <>
-void Key::CreateKey(ArenaAllocator &allocator, Key &key, string_t value);
-template <>
-void Key::CreateKey(ArenaAllocator &allocator, Key &key, const char *value);
-
+void Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, string_t value);
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/base_csv_reader.hpp

@@ -35,11 +35,9 @@ class BaseCSVReader {
 public:
 	BaseCSVReader(ClientContext &context, BufferedCSVReaderOptions options,
 	              const vector<LogicalType> &requested_types = vector<LogicalType>());
-
-	BaseCSVReader(FileSystem &fs, Allocator &allocator, FileOpener *opener, BufferedCSVReaderOptions options,
-	              const vector<LogicalType> &requested_types = vector<LogicalType>());
 	~BaseCSVReader();
 
+	ClientContext &context;
 	FileSystem &fs;
 	Allocator &allocator;
 	FileOpener *opener;

package/src/duckdb/src/include/duckdb/execution/operator/persistent/buffered_csv_reader.hpp

@@ -55,8 +55,6 @@ class BufferedCSVReader : public BaseCSVReader {
 public:
 	BufferedCSVReader(ClientContext &context, BufferedCSVReaderOptions options,
 	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
-	BufferedCSVReader(FileSystem &fs, Allocator &allocator, FileOpener *opener, BufferedCSVReaderOptions options,
-	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
 	BufferedCSVReader(ClientContext &context, string filename, BufferedCSVReaderOptions options,
 	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
 	~BufferedCSVReader();

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_reader_options.hpp

@@ -75,6 +75,8 @@ struct BufferedCSVReaderOptions {
 	case_insensitive_map_t<idx_t> sql_types_per_column;
 	//! User-defined SQL type list
 	vector<LogicalType> sql_type_list;
+	//! User-defined name list
+	vector<string> name_list;
 	//===--------------------------------------------------------------------===//
 	// ReadCSVOptions
 	//===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_detach.hpp

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/schema/physical_detach.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parser/parsed_data/detach_info.hpp"
+
+namespace duckdb {
+
+class PhysicalDetach : public PhysicalOperator {
+public:
+	explicit PhysicalDetach(unique_ptr<DetachInfo> info, idx_t estimated_cardinality)
+	    : PhysicalOperator(PhysicalOperatorType::DETACH, {LogicalType::BOOLEAN}, estimated_cardinality),
+	      info(std::move(info)) {
+	}
+
+	unique_ptr<DetachInfo> info;
+
+public:
+	// Source interface
+	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
+	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+	             LocalSourceState &lstate) const override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/client_data.hpp

@@ -11,7 +11,7 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/enums/output_type.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/atomic.hpp"
 
 namespace duckdb {
@@ -39,7 +39,7 @@ struct ClientData {
 	//! The set of temporary objects that belong to this client
 	shared_ptr<AttachedDatabase> temporary_objects;
 	//! The set of bound prepared statements that belong to this client
-	unordered_map<string, shared_ptr<PreparedStatementData>> prepared_statements;
+	case_insensitive_map_t<shared_ptr<PreparedStatementData>> prepared_statements;
 
 	//! The writer used to log queries (if logging is enabled)
 	unique_ptr<BufferedFileWriter> log_query_writer;

package/src/duckdb/src/include/duckdb/main/config.hpp

@@ -25,7 +25,6 @@
 #include "duckdb/storage/compression/bitpacking.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/replacement_scan.hpp"
-#include "duckdb/function/create_database_extension.hpp"
 #include "duckdb/optimizer/optimizer_extension.hpp"
 #include "duckdb/parser/parser_extension.hpp"
 #include "duckdb/planner/operator_extension.hpp"
@@ -185,8 +184,6 @@ public:
 	vector<std::unique_ptr<OperatorExtension>> operator_extensions;
 	//! Extensions made to storage
 	case_insensitive_map_t<std::unique_ptr<StorageExtension>> storage_extensions;
-	//! Extensions made to binder to implement the create_database functionality
-	vector<CreateDatabaseExtension> create_database_extensions;
 
 public:
 	DUCKDB_API static DBConfig &GetConfig(ClientContext &context);

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_database_info.hpp

@@ -16,9 +16,6 @@ struct CreateDatabaseInfo : public CreateInfo {
 	CreateDatabaseInfo() : CreateInfo(CatalogType::DATABASE_ENTRY) {
 	}
 
-	//! Extension name which creates databases
-	string extension_name;
-
 	//! Name of the database
 	string name;
 
@@ -29,7 +26,6 @@ public:
 	unique_ptr<CreateInfo> Copy() const override {
 		auto result = make_unique<CreateDatabaseInfo>();
 		CopyProperties(*result);
-		result->extension_name = extension_name;
 		result->name = name;
 		result->path = path;
 		return unique_ptr<CreateInfo>(result.release());

package/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/detach_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_data/parse_info.hpp"
+
+namespace duckdb {
+
+struct DetachInfo : public ParseInfo {
+	DetachInfo() {
+	}
+
+	//! The alias of the attached database
+	string name;
+	//! Whether to throw an exception if alias is not found
+	bool if_exists;
+
+public:
+	unique_ptr<DetachInfo> Copy() const {
+		auto result = make_unique<DetachInfo>();
+		result->name = name;
+		result->if_exists = if_exists;
+		return result;
+	}
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/query_node/select_node.hpp

@@ -21,7 +21,7 @@ namespace duckdb {
 //! SelectNode represents a standard SELECT statement
 class SelectNode : public QueryNode {
 public:
-	SelectNode();
+	DUCKDB_API SelectNode();
 
 	//! The projection list
 	vector<unique_ptr<ParsedExpression>> select_list;

package/src/duckdb/src/include/duckdb/parser/sql_statement.hpp

@@ -40,11 +40,11 @@ protected:
 	SQLStatement(const SQLStatement &other) = default;
 
 public:
-	virtual string ToString() const {
+	DUCKDB_API virtual string ToString() const {
 		throw InternalException("ToString not supported for this type of SQLStatement: '%s'",
 		                        StatementTypeToString(type));
 	}
 	//! Create a copy of this SelectStatement
-	virtual unique_ptr<SQLStatement> Copy() const = 0;
+	DUCKDB_API virtual unique_ptr<SQLStatement> Copy() const = 0;
 };
 } // namespace duckdb