duckdb 0.6.2-dev1162.0 → 0.6.2-dev1170.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev1162.0",
+  "version": "0.6.2-dev1170.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/parquet/parquet_reader.cpp

@@ -712,9 +712,9 @@ void ParquetReader::RearrangeChildReaders(unique_ptr<duckdb::ColumnReader> &root
 	unordered_map<idx_t, idx_t> reverse_union_idx;
 
 	for (idx_t col = 0; col < union_idx_map.size(); ++col) {
-		auto child_reader = move(root_struct_reader.child_readers[col]);
-		auto cast_reader = make_unique<CastColumnReader>(move(child_reader), union_col_types[union_idx_map[col]]);
-		root_struct_reader.child_readers[col] = move(cast_reader);
+		auto child_reader = std::move(root_struct_reader.child_readers[col]);
+		auto cast_reader = make_unique<CastColumnReader>(std::move(child_reader), union_col_types[union_idx_map[col]]);
+		root_struct_reader.child_readers[col] = std::move(cast_reader);
 		reverse_union_idx[union_idx_map[col]] = col;
 	}
 
@@ -726,7 +726,7 @@ void ParquetReader::RearrangeChildReaders(unique_ptr<duckdb::ColumnReader> &root
 			column_id_nulls[col] = false;
 		}
 	}
-	union_null_cols = move(column_id_nulls);
+	union_null_cols = std::move(column_id_nulls);
 }
 void FilterIsNull(Vector &v, parquet_filter_t &filter_mask, idx_t count) {
 	if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {

package/src/duckdb/src/common/sort/merge_sorter.cpp

@@ -334,8 +334,8 @@ void MergeSorter::MergeRadix(const idx_t &count, const bool left_smaller[]) {
 
 	auto &l_blocks = l.sb->radix_sorting_data;
 	auto &r_blocks = r.sb->radix_sorting_data;
-	RowDataBlock *l_block;
-	RowDataBlock *r_block;
+	RowDataBlock *l_block = nullptr;
+	RowDataBlock *r_block = nullptr;
 
 	data_ptr_t l_ptr;
 	data_ptr_t r_ptr;

package/src/duckdb/src/execution/index/art/node.cpp

@@ -278,7 +278,7 @@ Node *Node::Deserialize(ART &art, idx_t block_id, idx_t offset) {
 	reader.offset = offset;
 	auto n = reader.Read<uint8_t>();
 	NodeType node_type(static_cast<NodeType>(n));
-	Node *deserialized_node;
+	Node *deserialized_node = nullptr;
 	switch (node_type) {
 	case NodeType::NLeaf:
 		return Leaf::Deserialize(reader);

package/src/duckdb/src/execution/operator/persistent/buffered_csv_reader.cpp

@@ -40,9 +40,9 @@ BufferedCSVReader::BufferedCSVReader(ClientContext &context, BufferedCSVReaderOp
 BufferedCSVReader::BufferedCSVReader(ClientContext &context, string filename, BufferedCSVReaderOptions options_p,
                                      const vector<LogicalType> &requested_types)
     : BaseCSVReader(FileSystem::GetFileSystem(context), Allocator::Get(context), FileSystem::GetFileOpener(context),
-                    move(options_p), requested_types),
+                    std::move(options_p), requested_types),
       buffer_size(0), position(0), start(0) {
-	options.file_path = move(filename);
+	options.file_path = std::move(filename);
 	file_handle = OpenCSV(options);
 	Initialize(requested_types);
 }
@@ -832,6 +832,27 @@ vector<LogicalType> BufferedCSVReader::RefineTypeDetection(const vector<LogicalT
 	return detected_types;
 }
 
+string BufferedCSVReader::ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column,
+                                           const vector<string> &names) {
+	for (idx_t i = 0; i < names.size(); i++) {
+		auto it = sql_types_per_column.find(names[i]);
+		if (it != sql_types_per_column.end()) {
+			sql_types_per_column.erase(names[i]);
+			continue;
+		}
+	}
+	if (sql_types_per_column.empty()) {
+		return string();
+	}
+	string exception = "COLUMN_TYPES error: Columns with names: ";
+	for (auto &col : sql_types_per_column) {
+		exception += "\"" + col.first + "\",";
+	}
+	exception.pop_back();
+	exception += " do not exist in the CSV File";
+	return exception;
+}
+
 vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &requested_types) {
 	for (auto &type : requested_types) {
 		// auto detect for blobs not supported: there may be invalid UTF-8 in the file
@@ -887,23 +908,38 @@ vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &reque
 	// #######
 	options.num_cols = best_num_cols;
 	DetectHeader(best_sql_types_candidates, best_header_row);
-	auto sql_types_per_column = options.sql_types_per_column;
-	for (idx_t i = 0; i < names.size(); i++) {
-		auto it = sql_types_per_column.find(names[i]);
-		if (it != sql_types_per_column.end()) {
-			best_sql_types_candidates[i] = {it->second};
-			sql_types_per_column.erase(names[i]);
-		}
-	}
-	if (!sql_types_per_column.empty()) {
-		string exception = "COLUMN_TYPES error: Columns with names: ";
-		for (auto &col : sql_types_per_column) {
-			exception += "\"" + col.first + "\",";
+	if (!options.sql_type_list.empty()) {
+		// user-defined types were supplied for certain columns
+		// override the types
+		if (!options.sql_types_per_column.empty()) {
+			// types supplied as name -> value map
+			idx_t found = 0;
+			for (idx_t i = 0; i < names.size(); i++) {
+				auto it = options.sql_types_per_column.find(names[i]);
+				if (it != options.sql_types_per_column.end()) {
+					best_sql_types_candidates[i] = {options.sql_type_list[it->second]};
+					found++;
+					continue;
+				}
+			}
+			if (!options.union_by_name && found < options.sql_types_per_column.size()) {
+				string exception = ColumnTypesError(options.sql_types_per_column, names);
+				if (!exception.empty()) {
+					throw BinderException(exception);
+				}
+			}
+		} else {
+			// types supplied as list
+			if (names.size() < options.sql_type_list.size()) {
+				throw BinderException("read_csv: %d types were provided, but CSV file only has %d columns",
+				                      options.sql_type_list.size(), names.size());
+			}
+			for (idx_t i = 0; i < options.sql_type_list.size(); i++) {
+				best_sql_types_candidates[i] = {options.sql_type_list[i]};
+			}
 		}
-		exception.pop_back();
-		exception += " do not exist in the CSV File";
-		throw BinderException(exception);
 	}
+
 	// #######
 	// ### type detection (refining)
 	// #######

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

@@ -89,24 +89,45 @@ 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_types") {
+		} else if (loption == "column_types" || loption == "types" || loption == "dtypes") {
 			auto &child_type = kv.second.type();
-			if (child_type.id() != LogicalTypeId::STRUCT) {
-				throw BinderException("read_csv_auto column_types requires a struct as input");
+			if (child_type.id() != LogicalTypeId::STRUCT && child_type.id() != LogicalTypeId::LIST) {
+				throw BinderException("read_csv_auto %s requires a struct or list as input", kv.first);
 			}
-			auto &struct_children = StructValue::GetChildren(kv.second);
-			D_ASSERT(StructType::GetChildCount(child_type) == struct_children.size());
-			for (idx_t i = 0; i < struct_children.size(); i++) {
-				auto &name = StructType::GetChildName(child_type, i);
-				auto &val = struct_children[i];
-				if (val.type().id() != LogicalTypeId::VARCHAR) {
-					throw BinderException("read_csv_auto requires a type specification as string");
+			if (!options.sql_type_list.empty()) {
+				throw BinderException("read_csv_auto column_types/types/dtypes can only be supplied once");
+			}
+			vector<string> sql_type_names;
+			if (child_type.id() == LogicalTypeId::STRUCT) {
+				auto &struct_children = StructValue::GetChildren(kv.second);
+				D_ASSERT(StructType::GetChildCount(child_type) == struct_children.size());
+				for (idx_t i = 0; i < struct_children.size(); i++) {
+					auto &name = StructType::GetChildName(child_type, i);
+					auto &val = struct_children[i];
+					if (val.type().id() != LogicalTypeId::VARCHAR) {
+						throw BinderException("read_csv_auto %s requires a type specification as string", kv.first);
+					}
+					sql_type_names.push_back(StringValue::Get(val));
+					options.sql_types_per_column[name] = i;
 				}
-				auto def_type = TransformStringToLogicalType(StringValue::Get(val));
+			} else {
+				auto &list_child = ListType::GetChildType(child_type);
+				if (list_child.id() != LogicalTypeId::VARCHAR) {
+					throw BinderException("read_csv_auto %s requires a list of types (varchar) as input", kv.first);
+				}
+				auto &children = ListValue::GetChildren(kv.second);
+				for (auto &child : children) {
+					sql_type_names.push_back(StringValue::Get(child));
+				}
+			}
+			options.sql_type_list.reserve(sql_type_names.size());
+			for (auto &sql_type : sql_type_names) {
+				auto def_type = TransformStringToLogicalType(sql_type);
 				if (def_type.id() == LogicalTypeId::USER) {
-					throw BinderException("Unrecognized type for read_csv_auto column_types definition");
+					throw BinderException("Unrecognized type \"%s\" for read_csv_auto %s definition", sql_type,
+					                      kv.first);
 				}
-				options.sql_types_per_column[name] = def_type;
+				options.sql_type_list.push_back(move(def_type));
 			}
 		} else if (loption == "all_varchar") {
 			options.all_varchar = BooleanValue::Get(kv.second);
@@ -173,6 +194,13 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 		const idx_t first_file_index = 0;
 		result->initial_reader = std::move(result->union_readers[first_file_index]);
 		D_ASSERT(names.size() == return_types.size());
+
+		if (!options.sql_types_per_column.empty()) {
+			auto exception = BufferedCSVReader::ColumnTypesError(options.sql_types_per_column, names);
+			if (!exception.empty()) {
+				throw BinderException(exception);
+			}
+		}
 	}
 
 	if (result->options.include_file_name) {
@@ -830,6 +858,8 @@ TableFunction ReadCSVTableFunction::GetAutoFunction(bool list_parameter) {
 	read_csv_auto.cardinality = CSVReaderCardinality;
 	ReadCSVAddNamedParameters(read_csv_auto);
 	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;
 	return read_csv_auto;
 }
 

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev1162"
+#define DUCKDB_VERSION "0.6.2-dev1170"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "fc2ef0355a"
+#define DUCKDB_SOURCE_ID "72d187c5ff"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -51,7 +51,7 @@ public:
 					union_col_types.emplace_back(sql_types[col]);
 				}
 			}
-			union_readers.push_back(move(reader));
+			union_readers.push_back(std::move(reader));
 		}
 		return union_readers;
 	}
@@ -73,8 +73,8 @@ public:
 			}
 
 			reader->union_col_types = union_col_types;
-			reader->union_idx_map = move(union_idx_map);
-			reader->union_null_cols = move(union_null_cols);
+			reader->union_idx_map = std::move(union_idx_map);
+			reader->union_null_cols = std::move(union_null_cols);
 		}
 		return union_readers;
 	}

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

@@ -76,6 +76,8 @@ public:
 	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
 	void ParseCSV(DataChunk &insert_chunk);
 
+	static string ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column, const vector<string> &names);
+
 private:
 	//! Initialize Parser
 	void Initialize(const vector<LogicalType> &requested_types);

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

@@ -13,6 +13,7 @@
 #include "duckdb/function/scalar/strftime.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
@@ -54,8 +55,10 @@ struct BufferedCSVReaderOptions {
 	//===--------------------------------------------------------------------===//
 	// CSVAutoOptions
 	//===--------------------------------------------------------------------===//
-	//! SQL Types defined per specific column
-	unordered_map<string, LogicalType> sql_types_per_column;
+	//! SQL Type list mapping of name to SQL type index in sql_type_list
+	case_insensitive_map_t<idx_t> sql_types_per_column;
+	//! User-defined SQL type list
+	vector<LogicalType> sql_type_list;
 	//===--------------------------------------------------------------------===//
 	// ReadCSVOptions
 	//===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp

@@ -24,7 +24,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
+	static bool Equal(const BetweenExpression *a, const BetweenExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp

@@ -29,7 +29,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const CaseExpression *a, const CaseExpression *b);
+	static bool Equal(const CaseExpression *a, const CaseExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp

@@ -28,7 +28,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const CastExpression *a, const CastExpression *b);
+	static bool Equal(const CastExpression *a, const CastExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp

@@ -25,7 +25,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+	static bool Equal(const CollateExpression *a, const CollateExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp

@@ -38,7 +38,7 @@ public:
 	string GetName() const override;
 	string ToString() const override;
 
-	static bool Equals(const ColumnRefExpression *a, const ColumnRefExpression *b);
+	static bool Equal(const ColumnRefExpression *a, const ColumnRefExpression *b);
 	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;

package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp

@@ -24,7 +24,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
+	static bool Equal(const ComparisonExpression *a, const ComparisonExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp

@@ -28,7 +28,7 @@ public:
 
 	string ToString() const override;
 
-	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
+	static bool Equal(const ConjunctionExpression *a, const ConjunctionExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp

@@ -24,7 +24,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
+	static bool Equal(const ConstantExpression *a, const ConstantExpression *b);
 	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -50,7 +50,7 @@ public:
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
+	static bool Equal(const FunctionExpression *a, const FunctionExpression *b);
 	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;

package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp

@@ -30,7 +30,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
+	static bool Equal(const LambdaExpression *a, const LambdaExpression *b);
 	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -26,7 +26,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
+	static bool Equal(const OperatorExpression *a, const OperatorExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp

@@ -27,7 +27,7 @@ public:
 
 	string ToString() const override;
 
-	static bool Equals(const ParameterExpression *a, const ParameterExpression *b);
+	static bool Equal(const ParameterExpression *a, const ParameterExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 	hash_t Hash() const override;

package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp

@@ -24,7 +24,7 @@ public:
 
 	string ToString() const override;
 
-	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
+	static bool Equal(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
 	unique_ptr<ParsedExpression> Copy() const override;
 	hash_t Hash() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp

@@ -32,7 +32,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const StarExpression *a, const StarExpression *b);
+	static bool Equal(const StarExpression *a, const StarExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp

@@ -39,7 +39,7 @@ public:
 
 	string ToString() const override;
 
-	static bool Equals(const SubqueryExpression *a, const SubqueryExpression *b);
+	static bool Equal(const SubqueryExpression *a, const SubqueryExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp

@@ -65,7 +65,7 @@ public:
 	//! Convert the Expression to a String
 	string ToString() const override;
 
-	static bool Equals(const WindowExpression *a, const WindowExpression *b);
+	static bool Equal(const WindowExpression *a, const WindowExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

package/src/duckdb/src/parser/expression/between_expression.cpp

@@ -13,7 +13,7 @@ string BetweenExpression::ToString() const {
 	return ToString<BetweenExpression, ParsedExpression>(*this);
 }
 
-bool BetweenExpression::Equals(const BetweenExpression *a, const BetweenExpression *b) {
+bool BetweenExpression::Equal(const BetweenExpression *a, const BetweenExpression *b) {
 	if (!a->input->Equals(b->input.get())) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/case_expression.cpp

@@ -12,7 +12,7 @@ string CaseExpression::ToString() const {
 	return ToString<CaseExpression, ParsedExpression>(*this);
 }
 
-bool CaseExpression::Equals(const CaseExpression *a, const CaseExpression *b) {
+bool CaseExpression::Equal(const CaseExpression *a, const CaseExpression *b) {
 	if (a->case_checks.size() != b->case_checks.size()) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/cast_expression.cpp

@@ -16,7 +16,7 @@ string CastExpression::ToString() const {
 	return ToString<CastExpression, ParsedExpression>(*this);
 }
 
-bool CastExpression::Equals(const CastExpression *a, const CastExpression *b) {
+bool CastExpression::Equal(const CastExpression *a, const CastExpression *b) {
 	if (!a->child->Equals(b->child.get())) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/collate_expression.cpp

@@ -15,7 +15,7 @@ string CollateExpression::ToString() const {
 	return child->ToString() + " COLLATE " + KeywordHelper::WriteOptionallyQuoted(collation);
 }
 
-bool CollateExpression::Equals(const CollateExpression *a, const CollateExpression *b) {
+bool CollateExpression::Equal(const CollateExpression *a, const CollateExpression *b) {
 	if (!a->child->Equals(b->child.get())) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/columnref_expression.cpp

@@ -61,7 +61,7 @@ string ColumnRefExpression::ToString() const {
 	return result;
 }
 
-bool ColumnRefExpression::Equals(const ColumnRefExpression *a, const ColumnRefExpression *b) {
+bool ColumnRefExpression::Equal(const ColumnRefExpression *a, const ColumnRefExpression *b) {
 	if (a->column_names.size() != b->column_names.size()) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/comparison_expression.cpp

@@ -15,7 +15,7 @@ string ComparisonExpression::ToString() const {
 	return ToString<ComparisonExpression, ParsedExpression>(*this);
 }
 
-bool ComparisonExpression::Equals(const ComparisonExpression *a, const ComparisonExpression *b) {
+bool ComparisonExpression::Equal(const ComparisonExpression *a, const ComparisonExpression *b) {
 	if (!a->left->Equals(b->left.get())) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/conjunction_expression.cpp

@@ -39,7 +39,7 @@ string ConjunctionExpression::ToString() const {
 	return ToString<ConjunctionExpression, ParsedExpression>(*this);
 }
 
-bool ConjunctionExpression::Equals(const ConjunctionExpression *a, const ConjunctionExpression *b) {
+bool ConjunctionExpression::Equal(const ConjunctionExpression *a, const ConjunctionExpression *b) {
 	return ExpressionUtil::SetEquals(a->children, b->children);
 }
 

package/src/duckdb/src/parser/expression/constant_expression.cpp

@@ -15,7 +15,7 @@ string ConstantExpression::ToString() const {
 	return value.ToSQLString();
 }
 
-bool ConstantExpression::Equals(const ConstantExpression *a, const ConstantExpression *b) {
+bool ConstantExpression::Equal(const ConstantExpression *a, const ConstantExpression *b) {
 	return a->value.type() == b->value.type() && !ValueOperations::DistinctFrom(a->value, b->value);
 }
 

package/src/duckdb/src/parser/expression/function_expression.cpp

@@ -34,7 +34,7 @@ string FunctionExpression::ToString() const {
 	                                                      filter.get(), order_bys.get(), export_state, true);
 }
 
-bool FunctionExpression::Equals(const FunctionExpression *a, const FunctionExpression *b) {
+bool FunctionExpression::Equal(const FunctionExpression *a, const FunctionExpression *b) {
 	if (a->catalog != b->catalog || a->schema != b->schema || a->function_name != b->function_name ||
 	    b->distinct != a->distinct) {
 		return false;

package/src/duckdb/src/parser/expression/lambda_expression.cpp

@@ -13,7 +13,7 @@ string LambdaExpression::ToString() const {
 	return lhs->ToString() + " -> " + expr->ToString();
 }
 
-bool LambdaExpression::Equals(const LambdaExpression *a, const LambdaExpression *b) {
+bool LambdaExpression::Equal(const LambdaExpression *a, const LambdaExpression *b) {
 	return a->lhs->Equals(b->lhs.get()) && a->expr->Equals(b->expr.get());
 }
 

package/src/duckdb/src/parser/expression/operator_expression.cpp

@@ -24,7 +24,7 @@ string OperatorExpression::ToString() const {
 	return ToString<OperatorExpression, ParsedExpression>(*this);
 }
 
-bool OperatorExpression::Equals(const OperatorExpression *a, const OperatorExpression *b) {
+bool OperatorExpression::Equal(const OperatorExpression *a, const OperatorExpression *b) {
 	if (a->children.size() != b->children.size()) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/parameter_expression.cpp

@@ -22,7 +22,7 @@ unique_ptr<ParsedExpression> ParameterExpression::Copy() const {
 	return std::move(copy);
 }
 
-bool ParameterExpression::Equals(const ParameterExpression *a, const ParameterExpression *b) {
+bool ParameterExpression::Equal(const ParameterExpression *a, const ParameterExpression *b) {
 	return a->parameter_nr == b->parameter_nr;
 }
 

package/src/duckdb/src/parser/expression/positional_reference_expression.cpp

@@ -15,8 +15,8 @@ string PositionalReferenceExpression::ToString() const {
 	return "#" + to_string(index);
 }
 
-bool PositionalReferenceExpression::Equals(const PositionalReferenceExpression *a,
-                                           const PositionalReferenceExpression *b) {
+bool PositionalReferenceExpression::Equal(const PositionalReferenceExpression *a,
+                                          const PositionalReferenceExpression *b) {
 	return a->index == b->index;
 }
 

package/src/duckdb/src/parser/expression/star_expression.cpp

@@ -51,7 +51,7 @@ string StarExpression::ToString() const {
 	return result;
 }
 
-bool StarExpression::Equals(const StarExpression *a, const StarExpression *b) {
+bool StarExpression::Equal(const StarExpression *a, const StarExpression *b) {
 	if (a->relation_name != b->relation_name || a->exclude_list != b->exclude_list) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -26,7 +26,7 @@ string SubqueryExpression::ToString() const {
 	}
 }
 
-bool SubqueryExpression::Equals(const SubqueryExpression *a, const SubqueryExpression *b) {
+bool SubqueryExpression::Equal(const SubqueryExpression *a, const SubqueryExpression *b) {
 	if (!a->subquery || !b->subquery) {
 		return false;
 	}

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -32,7 +32,7 @@ string WindowExpression::ToString() const {
 	return ToString<WindowExpression, ParsedExpression, OrderByNode>(*this, schema, function_name);
 }
 
-bool WindowExpression::Equals(const WindowExpression *a, const WindowExpression *b) {
+bool WindowExpression::Equal(const WindowExpression *a, const WindowExpression *b) {
 	// check if the child expressions are equivalent
 	if (b->children.size() != a->children.size()) {
 		return false;
@@ -48,7 +48,7 @@ bool WindowExpression::Equals(const WindowExpression *a, const WindowExpression
 	if (a->start != b->start || a->end != b->end) {
 		return false;
 	}
-	// check if the framing expressions are equivalent
+	// check if the framing expressions are equivalentbind_
 	if (!BaseExpression::Equals(a->start_expr.get(), b->start_expr.get()) ||
 	    !BaseExpression::Equals(a->end_expr.get(), b->end_expr.get()) ||
 	    !BaseExpression::Equals(a->offset_expr.get(), b->offset_expr.get()) ||

package/src/duckdb/src/parser/parsed_expression.cpp

@@ -52,40 +52,40 @@ bool ParsedExpression::Equals(const BaseExpression *other) const {
 	}
 	switch (expression_class) {
 	case ExpressionClass::BETWEEN:
-		return BetweenExpression::Equals((BetweenExpression *)this, (BetweenExpression *)other);
+		return BetweenExpression::Equal((BetweenExpression *)this, (BetweenExpression *)other);
 	case ExpressionClass::CASE:
-		return CaseExpression::Equals((CaseExpression *)this, (CaseExpression *)other);
+		return CaseExpression::Equal((CaseExpression *)this, (CaseExpression *)other);
 	case ExpressionClass::CAST:
-		return CastExpression::Equals((CastExpression *)this, (CastExpression *)other);
+		return CastExpression::Equal((CastExpression *)this, (CastExpression *)other);
 	case ExpressionClass::COLLATE:
-		return CollateExpression::Equals((CollateExpression *)this, (CollateExpression *)other);
+		return CollateExpression::Equal((CollateExpression *)this, (CollateExpression *)other);
 	case ExpressionClass::COLUMN_REF:
-		return ColumnRefExpression::Equals((ColumnRefExpression *)this, (ColumnRefExpression *)other);
+		return ColumnRefExpression::Equal((ColumnRefExpression *)this, (ColumnRefExpression *)other);
 	case ExpressionClass::COMPARISON:
-		return ComparisonExpression::Equals((ComparisonExpression *)this, (ComparisonExpression *)other);
+		return ComparisonExpression::Equal((ComparisonExpression *)this, (ComparisonExpression *)other);
 	case ExpressionClass::CONJUNCTION:
-		return ConjunctionExpression::Equals((ConjunctionExpression *)this, (ConjunctionExpression *)other);
+		return ConjunctionExpression::Equal((ConjunctionExpression *)this, (ConjunctionExpression *)other);
 	case ExpressionClass::CONSTANT:
-		return ConstantExpression::Equals((ConstantExpression *)this, (ConstantExpression *)other);
+		return ConstantExpression::Equal((ConstantExpression *)this, (ConstantExpression *)other);
 	case ExpressionClass::DEFAULT:
 		return true;
 	case ExpressionClass::FUNCTION:
-		return FunctionExpression::Equals((FunctionExpression *)this, (FunctionExpression *)other);
+		return FunctionExpression::Equal((FunctionExpression *)this, (FunctionExpression *)other);
 	case ExpressionClass::LAMBDA:
-		return LambdaExpression::Equals((LambdaExpression *)this, (LambdaExpression *)other);
+		return LambdaExpression::Equal((LambdaExpression *)this, (LambdaExpression *)other);
 	case ExpressionClass::OPERATOR:
-		return OperatorExpression::Equals((OperatorExpression *)this, (OperatorExpression *)other);
+		return OperatorExpression::Equal((OperatorExpression *)this, (OperatorExpression *)other);
 	case ExpressionClass::PARAMETER:
-		return ParameterExpression::Equals((ParameterExpression *)this, (ParameterExpression *)other);
+		return ParameterExpression::Equal((ParameterExpression *)this, (ParameterExpression *)other);
 	case ExpressionClass::POSITIONAL_REFERENCE:
-		return PositionalReferenceExpression::Equals((PositionalReferenceExpression *)this,
-		                                             (PositionalReferenceExpression *)other);
+		return PositionalReferenceExpression::Equal((PositionalReferenceExpression *)this,
+		                                            (PositionalReferenceExpression *)other);
 	case ExpressionClass::STAR:
-		return StarExpression::Equals((StarExpression *)this, (StarExpression *)other);
+		return StarExpression::Equal((StarExpression *)this, (StarExpression *)other);
 	case ExpressionClass::SUBQUERY:
-		return SubqueryExpression::Equals((SubqueryExpression *)this, (SubqueryExpression *)other);
+		return SubqueryExpression::Equal((SubqueryExpression *)this, (SubqueryExpression *)other);
 	case ExpressionClass::WINDOW:
-		return WindowExpression::Equals((WindowExpression *)this, (WindowExpression *)other);
+		return WindowExpression::Equal((WindowExpression *)this, (WindowExpression *)other);
 	default:
 		throw SerializationException("Unsupported type for expression comparison!");
 	}

package/src/duckdb/src/planner/binder/query_node/bind_select_node.cpp

@@ -269,7 +269,7 @@ bool Binder::FindStarExpression(ParsedExpression &expr, StarExpression **star) {
 		auto current_star = (StarExpression *)&expr;
 		if (*star) {
 			// we can have multiple
-			if (!StarExpression::Equals(*star, current_star)) {
+			if (!StarExpression::Equal(*star, current_star)) {
 				throw BinderException(
 				    FormatError(expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
 			}

package/src/duckdb/third_party/fmt/include/fmt/core.h

@@ -355,16 +355,14 @@ template <typename Char> class basic_string_view {
 using string_view = basic_string_view<char>;
 using wstring_view = basic_string_view<wchar_t>;
 
-#ifndef __cpp_char8_t
 // A UTF-8 code unit type.
-enum char8_t : unsigned char {};
-#endif
+typedef unsigned char fmt_char8_t;
 
 /** Specifies if ``T`` is a character type. Can be specialized by users. */
 template <typename T> struct is_char : std::false_type {};
 template <> struct is_char<char> : std::true_type {};
 template <> struct is_char<wchar_t> : std::true_type {};
-template <> struct is_char<char8_t> : std::true_type {};
+template <> struct is_char<fmt_char8_t> : std::true_type {};
 template <> struct is_char<char16_t> : std::true_type {};
 template <> struct is_char<char32_t> : std::true_type {};
 

package/src/duckdb/third_party/fmt/include/fmt/format.h

@@ -457,8 +457,8 @@ inline size_t count_code_points(basic_string_view<Char> s) {
 }
 
 // Counts the number of code points in a UTF-8 string.
-inline size_t count_code_points(basic_string_view<char8_t> s) {
-  const char8_t* data = s.data();
+inline size_t count_code_points(basic_string_view<fmt_char8_t> s) {
+  const fmt_char8_t* data = s.data();
   size_t num_code_points = 0;
   for (size_t i = 0, size = s.size(); i != size; ++i) {
     if ((data[i] & 0xc0) != 0x80) ++num_code_points;
@@ -473,8 +473,8 @@ inline size_t code_point_index(basic_string_view<Char> s, size_t n) {
 }
 
 // Calculates the index of the nth code point in a UTF-8 string.
-inline size_t code_point_index(basic_string_view<char8_t> s, size_t n) {
-  const char8_t* data = s.data();
+inline size_t code_point_index(basic_string_view<fmt_char8_t> s, size_t n) {
+  const fmt_char8_t* data = s.data();
   size_t num_code_points = 0;
   for (size_t i = 0, size = s.size(); i != size; ++i) {
     if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) {
@@ -484,13 +484,13 @@ inline size_t code_point_index(basic_string_view<char8_t> s, size_t n) {
   return s.size();
 }
 
-inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
+inline fmt_char8_t to_fmt_char8_t(char c) { return static_cast<fmt_char8_t>(c); }
 
 template <typename InputIt, typename OutChar>
 using needs_conversion = bool_constant<
     std::is_same<typename std::iterator_traits<InputIt>::value_type,
                  char>::value &&
-    std::is_same<OutChar, char8_t>::value>;
+    std::is_same<OutChar, fmt_char8_t>::value>;
 
 template <typename OutChar, typename InputIt, typename OutputIt,
           FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
@@ -501,7 +501,7 @@ OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
 template <typename OutChar, typename InputIt, typename OutputIt,
           FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
 OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::transform(begin, end, it, to_char8_t);
+  return std::transform(begin, end, it, to_fmt_char8_t);
 }
 
 #ifndef FMT_USE_GRISU
@@ -535,12 +535,12 @@ class buffer_range : public internal::output_range<
 };
 
 // A UTF-8 string view.
-class u8string_view : public basic_string_view<char8_t> {
+class u8string_view : public basic_string_view<fmt_char8_t> {
  public:
   u8string_view(const char* s)
-      : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s)) {}
+      : basic_string_view<fmt_char8_t>(reinterpret_cast<const fmt_char8_t*>(s)) {}
   u8string_view(const char* s, size_t count) FMT_NOEXCEPT
-      : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s), count) {
+      : basic_string_view<fmt_char8_t>(reinterpret_cast<const fmt_char8_t*>(s), count) {
   }
 };
 

package/src/duckdb/third_party/thrift/thrift/TApplicationException.h

@@ -100,9 +100,6 @@ public:
     }
   }
 
-  uint32_t read(protocol::TProtocol* iprot);
-  uint32_t write(protocol::TProtocol* oprot) const;
-
 protected:
   /**
    * Error code