duckdb 0.7.1-dev90.0 → 0.7.1

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

@@ -28,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 FileSystem::MissingFileException(file_pattern, context);
-		}
+		auto found_files = fs.GlobFiles(file_pattern, context);
 		files.insert(files.end(), found_files.begin(), found_files.end());
 	}
 }
@@ -99,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) {
@@ -301,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;
 	}
@@ -573,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) {
@@ -961,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-dev90"
+#define DUCKDB_VERSION "0.7.1"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "1b87fb94ca"
+#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/statement_type.hpp

@@ -48,7 +48,7 @@ enum class StatementType : uint8_t {
 
 };
 
-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/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);
@@ -201,7 +202,6 @@ 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/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/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/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
 	//===--------------------------------------------------------------------===//