duckdb 0.7.1-dev7.0 → 0.7.1

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -1,10 +1,12 @@
-#include "duckdb/function/pragma/pragma_functions.hpp"
-#include "duckdb/common/string_util.hpp"
+#include "duckdb/common/constants.hpp"
 #include "duckdb/common/file_system.hpp"
-#include "duckdb/parser/statement/export_statement.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/parser.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/function/pragma/pragma_functions.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/parser/parser.hpp"
+#include "duckdb/parser/qualified_name.hpp"
+#include "duckdb/parser/statement/copy_statement.hpp"
+#include "duckdb/parser/statement/export_statement.hpp"
 
 namespace duckdb {
 
@@ -20,8 +22,8 @@ string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters
 	return R"(
 			SELECT
 				t.table_name,
-				LIST(c.column_name order by c.column_name) AS column_names,
-				LIST(c.data_type order by c.column_name) AS column_types,
+				LIST(c.column_name order by c.column_index) AS column_names,
+				LIST(c.data_type order by c.column_index) AS column_types,
 				FIRST(t.temporary) AS temporary
 			FROM duckdb_tables t
 			JOIN duckdb_columns c
@@ -58,10 +60,35 @@ string PragmaFunctionsQuery(ClientContext &context, const FunctionParameters &pa
 
 string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
 	// PRAGMA table_info but with some aliases
-	return StringUtil::Format(
-	    "SELECT name AS \"column_name\", type as \"column_type\", CASE WHEN \"notnull\" THEN 'NO' ELSE 'YES' "
-	    "END AS \"null\", NULL AS \"key\", dflt_value AS \"default\", NULL AS \"extra\" FROM pragma_table_info('%s');",
-	    parameters.values[0].ToString());
+	auto table = QualifiedName::Parse(parameters.values[0].ToString());
+
+	// clang-format off
+    string sql = R"(
+	SELECT
+		name AS "column_name",
+		type as "column_type",
+		CASE WHEN "notnull" THEN 'NO' ELSE 'YES' END AS "null",
+		(SELECT 
+			MIN(CASE 
+				WHEN constraint_type='PRIMARY KEY' THEN 'PRI'
+				WHEN constraint_type='UNIQUE' THEN 'UNI' 
+				ELSE NULL END) 
+		FROM duckdb_constraints() c  
+		WHERE c.table_oid=cols.table_oid 
+		AND list_contains(constraint_column_names, cols.column_name)) AS "key",
+		dflt_value AS "default", 
+		NULL AS "extra" 
+	FROM pragma_table_info('%func_param_table%') 
+	LEFT JOIN duckdb_columns cols 
+	ON cols.column_name = pragma_table_info.name 
+	AND cols.table_name='%table_name%'
+	AND cols.schema_name='%table_schema%';)";
+	// clang-format on
+
+	sql = StringUtil::Replace(sql, "%func_param_table%", parameters.values[0].ToString());
+	sql = StringUtil::Replace(sql, "%table_name%", table.name);
+	sql = StringUtil::Replace(sql, "%table_schema%", table.schema.empty() ? DEFAULT_SCHEMA : table.schema);
+	return sql;
 }
 
 string PragmaVersion(ClientContext &context, const FunctionParameters &parameters) {

package/src/duckdb/src/function/scalar/generic/current_setting.cpp

@@ -4,7 +4,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-
+#include "duckdb/catalog/catalog.hpp"
 namespace duckdb {
 
 struct CurrentSettingBindData : public FunctionData {
@@ -51,7 +51,7 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	auto key = StringUtil::Lower(key_str);
 	Value val;
 	if (!context.TryGetCurrentSetting(key, val)) {
-		throw InvalidInputException("unrecognized configuration parameter \"%s\"", key_str);
+		throw Catalog::UnrecognizedConfigurationError(context, key);
 	}
 
 	bound_function.return_type = val.type();

package/src/duckdb/src/function/scalar/list/array_slice.cpp

@@ -52,6 +52,7 @@ template <typename INPUT_TYPE, typename INDEX_TYPE>
 static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end, bool begin_valid, bool end_valid) {
 	// Clamp offsets
 	begin = begin_valid ? begin : 0;
+	begin = (begin > 0) ? begin - 1 : begin;
 	end = end_valid ? end : ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
 	if (!ClampIndex(begin, value) || !ClampIndex(end, value)) {
 		return false;
@@ -88,7 +89,7 @@ static void ExecuteSlice(Vector &result, Vector &s, Vector &b, Vector &e, const
 		auto edata = ConstantVector::GetData<INDEX_TYPE>(e);
 
 		auto sliced = sdata[0];
-		auto begin = (bdata[0] > 0) ? bdata[0] - 1 : bdata[0];
+		auto begin = bdata[0];
 		auto end = edata[0];
 
 		auto svalid = !ConstantVector::IsNull(s);
@@ -120,8 +121,6 @@ static void ExecuteSlice(Vector &result, Vector &s, Vector &b, Vector &e, const
 			auto begin = ((INDEX_TYPE *)bdata.data)[bidx];
 			auto end = ((INDEX_TYPE *)edata.data)[eidx];
 
-			begin = (begin > 0) ? begin - 1 : begin;
-
 			auto svalid = sdata.validity.RowIsValid(sidx);
 			auto bvalid = bdata.validity.RowIsValid(bidx);
 			auto evalid = edata.validity.RowIsValid(eidx);

package/src/duckdb/src/function/scalar/map/map.cpp

@@ -66,46 +66,94 @@ void MapConversionVerify(Vector &vector, idx_t count) {
 	}
 }
 
-static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
-
-	//! Otherwise if its not a constant vector, this breaks the optimizer
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
+// Example:
+// source: [1,2,3], expansion_factor: 4
+// target (result): [1,2,3,1,2,3,1,2,3,1,2,3]
+static void CreateExpandedVector(const Vector &source, Vector &target, idx_t expansion_factor) {
+	idx_t count = ListVector::GetListSize(source);
+	auto &entry = ListVector::GetEntry(source);
+
+	idx_t target_idx = 0;
+	for (idx_t copy = 0; copy < expansion_factor; copy++) {
+		for (idx_t key_idx = 0; key_idx < count; key_idx++) {
+			target.SetValue(target_idx, entry.GetValue(key_idx));
+			target_idx++;
 		}
 	}
+	D_ASSERT(target_idx == count * expansion_factor);
+}
+
+static void AlignVectorToReference(const Vector &original, const Vector &reference, idx_t tuple_count, Vector &result) {
+	auto original_length = ListVector::GetListSize(original);
+	auto new_length = ListVector::GetListSize(reference);
+
+	Vector expanded_const(ListType::GetChildType(original.GetType()), new_length);
+
+	auto expansion_factor = new_length / original_length;
+	if (expansion_factor != tuple_count) {
+		throw InvalidInputException("Error in MAP creation: key list and value list do not align. i.e. different "
+		                            "size or incompatible structure");
+	}
+	CreateExpandedVector(original, expanded_const, expansion_factor);
+	result.Reference(expanded_const);
+}
+
+static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
 
 	auto &key_vector = MapVector::GetKeys(result);
 	auto &value_vector = MapVector::GetValues(result);
-	auto list_data = ListVector::GetData(result);
+	auto result_data = ListVector::GetData(result);
 
+	result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	if (args.data.empty()) {
 		ListVector::SetListSize(result, 0);
-		list_data->offset = 0;
-		list_data->length = 0;
+		result_data->offset = 0;
+		result_data->length = 0;
 		result.Verify(args.size());
 		return;
 	}
 
-	auto args_data = ListVector::GetData(args.data[0]);
+	bool keys_are_const = args.data[0].GetVectorType() == VectorType::CONSTANT_VECTOR;
+	bool values_are_const = args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR;
+	if (!keys_are_const || !values_are_const) {
+		result.SetVectorType(VectorType::FLAT_VECTOR);
+	}
+
 	auto key_count = ListVector::GetListSize(args.data[0]);
 	auto value_count = ListVector::GetListSize(args.data[1]);
-	if (key_count != value_count) {
-		throw InvalidInputException(
-		    "Error in MAP creation: key list has a different size from value list (%lld keys, %lld values)", key_count,
-		    value_count);
+	auto key_data = ListVector::GetData(args.data[0]);
+	auto value_data = ListVector::GetData(args.data[1]);
+	auto src_data = key_data;
+
+	if (keys_are_const && !values_are_const) {
+		AlignVectorToReference(args.data[0], args.data[1], args.size(), key_vector);
+		src_data = value_data;
+	} else if (values_are_const && !keys_are_const) {
+		AlignVectorToReference(args.data[1], args.data[0], args.size(), value_vector);
+	} else {
+		if (key_count != value_count || memcmp(key_data, value_data, args.size() * sizeof(list_entry_t)) != 0) {
+			throw InvalidInputException("Error in MAP creation: key list and value list do not align. i.e. different "
+			                            "size or incompatible structure");
+		}
 	}
-	ListVector::Reserve(result, key_count);
-	ListVector::SetListSize(result, key_count);
 
+	ListVector::SetListSize(result, MaxValue(key_count, value_count));
+
+	result_data = ListVector::GetData(result);
 	for (idx_t i = 0; i < args.size(); i++) {
-		list_data[i] = args_data[i];
+		result_data[i] = src_data[i];
+	}
+
+	// check whether one of the vectors has already been referenced to an expanded vector in the case of const/non-const
+	// combination. If not, then referencing is still necessary
+	if (!(keys_are_const && !values_are_const)) {
+		key_vector.Reference(ListVector::GetEntry(args.data[0]));
+	}
+	if (!(values_are_const && !keys_are_const)) {
+		value_vector.Reference(ListVector::GetEntry(args.data[1]));
 	}
 
-	key_vector.Reference(ListVector::GetEntry(args.data[0]));
-	value_vector.Reference(ListVector::GetEntry(args.data[1]));
 	MapConversionVerify(result, args.size());
 	result.Verify(args.size());
 }

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -220,7 +220,7 @@ bool LikeOperatorFunction(string_t &s, string_t &pat, char escape) {
 	return LikeOperatorFunction(s.GetDataUnsafe(), s.GetSize(), pat.GetDataUnsafe(), pat.GetSize(), escape);
 }
 
-bool LikeFun::Glob(const char *string, idx_t slen, const char *pattern, idx_t plen) {
+bool LikeFun::Glob(const char *string, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark) {
 	idx_t sidx = 0;
 	idx_t pidx = 0;
 main_loop : {
@@ -249,8 +249,11 @@ main_loop : {
 			return false;
 		}
 		case '?':
-			// wildcard: matches anything but null
-			break;
+			// when enabled: matches anything but null
+			if (allow_question_mark) {
+				break;
+			}
+			DUCKDB_EXPLICIT_FALLTHROUGH;
 		case '[':
 			pidx++;
 			goto parse_bracket;

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>
 
@@ -27,10 +28,7 @@ unique_ptr<CSVFileHandle> ReadCSV::OpenCSV(const string &file_path, FileCompress
 void ReadCSVData::InitializeFiles(ClientContext &context, const vector<string> &patterns) {
 	auto &fs = FileSystem::GetFileSystem(context);
 	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);
-		}
+		auto found_files = fs.GlobFiles(file_pattern, context);
 		files.insert(files.end(), found_files.begin(), found_files.end());
 	}
 }
@@ -98,6 +96,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 +260,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 +309,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 +581,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 +970,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/system/duckdb_temporary_files.cpp

@@ -0,0 +1,59 @@
+#include "duckdb/function/table/system_functions.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+
+namespace duckdb {
+
+struct DuckDBTemporaryFilesData : public GlobalTableFunctionState {
+	DuckDBTemporaryFilesData() : offset(0) {
+	}
+
+	vector<TemporaryFileInformation> entries;
+	idx_t offset;
+};
+
+static unique_ptr<FunctionData> DuckDBTemporaryFilesBind(ClientContext &context, TableFunctionBindInput &input,
+                                                         vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("path");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("size");
+	return_types.emplace_back(LogicalType::BIGINT);
+
+	return nullptr;
+}
+
+unique_ptr<GlobalTableFunctionState> DuckDBTemporaryFilesInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto result = make_unique<DuckDBTemporaryFilesData>();
+
+	result->entries = BufferManager::GetBufferManager(context).GetTemporaryFiles();
+	return std::move(result);
+}
+
+void DuckDBTemporaryFilesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBTemporaryFilesData &)*data_p.global_state;
+	if (data.offset >= data.entries.size()) {
+		// finished returning values
+		return;
+	}
+	// start returning values
+	// either fill up the chunk or return all the remaining columns
+	idx_t count = 0;
+	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
+		auto &entry = data.entries[data.offset++];
+		// return values:
+		idx_t col = 0;
+		// database_name, VARCHAR
+		output.SetValue(col++, count, entry.path);
+		// database_oid, BIGINT
+		output.SetValue(col++, count, Value::BIGINT(entry.size));
+		count++;
+	}
+	output.SetCardinality(count);
+}
+
+void DuckDBTemporaryFilesFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(TableFunction("duckdb_temporary_files", {}, DuckDBTemporaryFilesFunction, DuckDBTemporaryFilesBind,
+	                              DuckDBTemporaryFilesInit));
+}
+
+} // namespace duckdb

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

@@ -29,6 +29,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	DuckDBSequencesFun::RegisterFunction(*this);
 	DuckDBSettingsFun::RegisterFunction(*this);
 	DuckDBTablesFun::RegisterFunction(*this);
+	DuckDBTemporaryFilesFun::RegisterFunction(*this);
 	DuckDBTypesFun::RegisterFunction(*this);
 	DuckDBViewsFun::RegisterFunction(*this);
 	TestAllTypesFun::RegisterFunction(*this);

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-dev7"
+#define DUCKDB_VERSION "0.7.1"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "05803a9db2"
+#define DUCKDB_SOURCE_ID "b00b93f0b1"
 #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.
@@ -251,6 +255,8 @@ public:
 
 	virtual void Verify();
 
+	static CatalogException UnrecognizedConfigurationError(ClientContext &context, const string &name);
+
 protected:
 	//! Reference to the database
 	AttachedDatabase &db;

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/bind_helpers.hpp

@@ -17,5 +17,7 @@ class Value;
 Value ConvertVectorToValue(vector<Value> set);
 vector<bool> ParseColumnList(const vector<Value> &set, vector<string> &names, const string &option_name);
 vector<bool> ParseColumnList(const Value &value, vector<string> &names, const string &option_name);
+vector<idx_t> ParseColumnsOrdered(const vector<Value> &set, vector<string> &names, const string &loption);
+vector<idx_t> ParseColumnsOrdered(const Value &value, vector<string> &names, const string &loption);
 
 } // namespace duckdb

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

@@ -188,6 +188,7 @@ public:
 	//! Runs a glob on the file system, returning a list of matching files
 	DUCKDB_API virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr);
 	DUCKDB_API virtual vector<string> Glob(const string &path, ClientContext &context);
+	DUCKDB_API vector<string> GlobFiles(const string &path, ClientContext &context);
 
 	//! registers a sub-file system to handle certain file name prefixes, e.g. http:// etc.
 	DUCKDB_API virtual void RegisterSubSystem(unique_ptr<FileSystem> sub_fs);

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/string_util.hpp

@@ -145,8 +145,15 @@ public:
 	DUCKDB_API static string Replace(string source, const string &from, const string &to);
 
 	//! Get the levenshtein distance from two strings
-	DUCKDB_API static idx_t LevenshteinDistance(const string &s1, const string &s2);
-
+	//! The not_equal_penalty is the penalty given when two characters in a string are not equal
+	//! The regular levenshtein distance has a not equal penalty of 1, which means changing a character is as expensive
+	//! as adding or removing one For similarity searches we often want to give extra weight to changing a character For
+	//! example: with an equal penalty of 1, "pg_am" is closer to "depdelay" than "depdelay_minutes"
+	//! with an equal penalty of 3, "depdelay_minutes" is closer to "depdelay" than to "pg_am"
+	DUCKDB_API static idx_t LevenshteinDistance(const string &s1, const string &s2, idx_t not_equal_penalty = 1);
+
+	//! Returns the similarity score between two strings
+	DUCKDB_API static idx_t SimilarityScore(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.

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