duckdb 0.9.1-dev97.0 → 0.9.1

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp

@@ -39,18 +39,18 @@ SnifferResult CSVSniffer::SniffCSV() {
 	DetectDialect();
 	// 2. Type Detection
 	DetectTypes();
-	// 3. Header Detection
+	// 3. Type Refinement
+	RefineTypes();
+	// 4. Header Detection
 	DetectHeader();
 	if (explicit_set_columns) {
 		SetResultOptions();
 		// We do not need to run type refinement, since the types have been given by the user
 		return SnifferResult({}, {});
 	}
-	D_ASSERT(best_sql_types_candidates_per_column_idx.size() == names.size());
-	// 4. Type Replacement
+	// 5. Type Replacement
 	ReplaceTypes();
-	// 5. Type Refinement
-	RefineTypes();
+	D_ASSERT(best_sql_types_candidates_per_column_idx.size() == names.size());
 	// We are done, Set the CSV Options in the reference. Construct and return the result.
 	SetResultOptions();
 	return SnifferResult(detected_types, names);

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp

@@ -5,9 +5,9 @@ namespace duckdb {
 
 struct SniffDialect {
 	inline static void Initialize(CSVStateMachine &machine) {
-		machine.state = CSVState::STANDARD;
-		machine.previous_state = CSVState::STANDARD;
-		machine.pre_previous_state = CSVState::STANDARD;
+		machine.state = CSVState::EMPTY_LINE;
+		machine.previous_state = CSVState::EMPTY_LINE;
+		machine.pre_previous_state = CSVState::EMPTY_LINE;
 		machine.cur_rows = 0;
 		machine.column_count = 1;
 	}
@@ -299,7 +299,7 @@ void CSVSniffer::DetectDialect() {
 	unordered_map<uint8_t, vector<char>> quote_candidates_map;
 	// Candidates for the escape option
 	unordered_map<uint8_t, vector<char>> escape_candidates_map;
-	escape_candidates_map[(uint8_t)QuoteRule::QUOTES_RFC] = {'\0', '\"', '\''};
+	escape_candidates_map[(uint8_t)QuoteRule::QUOTES_RFC] = {'\"', '\'', '\0'};
 	escape_candidates_map[(uint8_t)QuoteRule::QUOTES_OTHER] = {'\\'};
 	escape_candidates_map[(uint8_t)QuoteRule::NO_QUOTES] = {'\0'};
 	// Number of rows read

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_replacement.cpp

@@ -14,7 +14,7 @@ void CSVSniffer::ReplaceTypes() {
 		for (idx_t i = 0; i < names.size(); i++) {
 			auto it = best_candidate->options.sql_types_per_column.find(names[i]);
 			if (it != best_candidate->options.sql_types_per_column.end()) {
-				best_sql_types_candidates_per_column_idx[i] = {best_candidate->options.sql_type_list[it->second]};
+				detected_types[i] = best_candidate->options.sql_type_list[it->second];
 				found++;
 			}
 		}
@@ -33,7 +33,7 @@ void CSVSniffer::ReplaceTypes() {
 		                      best_candidate->options.sql_type_list.size(), names.size());
 	}
 	for (idx_t i = 0; i < best_candidate->options.sql_type_list.size(); i++) {
-		best_sql_types_candidates_per_column_idx[i] = {best_candidate->options.sql_type_list[i]};
+		detected_types[i] = best_candidate->options.sql_type_list[i];
 	}
 }
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_reset.cpp

@@ -21,10 +21,7 @@ void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig &
 
 SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	auto &config = DBConfig::GetConfig(context.client);
-	if (config.options.lock_configuration) {
-		throw InvalidInputException("Cannot reset configuration option \"%s\" - the configuration has been locked",
-		                            name);
-	}
+	config.CheckLock(name);
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable

package/src/duckdb/src/execution/operator/helper/physical_set.cpp

@@ -24,10 +24,8 @@ void PhysicalSet::SetExtensionVariable(ClientContext &context, ExtensionOption &
 
 SourceResultType PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	auto &config = DBConfig::GetConfig(context.client);
-	if (config.options.lock_configuration) {
-		throw InvalidInputException("Cannot change configuration option \"%s\" - the configuration has been locked",
-		                            name);
-	}
+	// check if we are allowed to change the configuration option
+	config.CheckLock(name);
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable

package/src/duckdb/src/function/function_binder.cpp

@@ -228,7 +228,7 @@ void FunctionBinder::CastToFunctionArguments(SimpleFunction &function, vector<un
 	for (idx_t i = 0; i < children.size(); i++) {
 		auto target_type = i < function.arguments.size() ? function.arguments[i] : function.varargs;
 		target_type.Verify();
-		// don't cast lambda children, they get removed anyways
+		// don't cast lambda children, they get removed before execution
 		if (children[i]->return_type.id() == LogicalTypeId::LAMBDA) {
 			continue;
 		}

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

@@ -639,10 +639,11 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 		for (idx_t type_idx = 0; type_idx < static_cast<idx_t>(array.n_children); type_idx++) {
 			Vector child(members[type_idx].second);
 			auto arrow_array = array.children[type_idx];
+			auto &child_type = arrow_type[type_idx];
 
 			SetValidityMask(child, *arrow_array, scan_state, size, nested_offset);
 
-			ColumnArrowToDuckDB(child, *arrow_array, scan_state, size, arrow_type, nested_offset, &validity_mask);
+			ColumnArrowToDuckDB(child, *arrow_array, scan_state, size, child_type, nested_offset, &validity_mask);
 
 			children.push_back(std::move(child));
 		}

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v0.9.1-dev97"
+#define DUCKDB_VERSION "v0.9.1"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "0894f3d6ab"
+#define DUCKDB_SOURCE_ID "401c8061c6"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp

@@ -27,6 +27,7 @@ typedef void (*finalize_t)(ArrowAppendData &append_data, const LogicalType &type
 // ArrowAppendState
 struct ArrowAppendData {
 	explicit ArrowAppendData(ClientProperties &options_p) : options(options_p) {
+		dictionary.release = nullptr;
 	}
 	// the buffers of the arrow vector
 	ArrowBuffer validity;
@@ -48,6 +49,9 @@ struct ArrowAppendData {
 	unique_ptr<ArrowArray> array;
 	duckdb::array<const void *, 3> buffers = {{nullptr, nullptr, nullptr}};
 	vector<ArrowArray *> child_pointers;
+	// Arrays so the children can be moved
+	vector<ArrowArray> child_arrays;
+	ArrowArray dictionary;
 
 	ClientProperties options;
 };

package/src/duckdb/src/include/duckdb/common/arrow/appender/enum_data.hpp

@@ -62,7 +62,9 @@ struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
 		result->n_buffers = 2;
 		result->buffers[1] = append_data.main_buffer.data();
 		// finalize the enum child data, and assign it to the dictionary
-		result->dictionary = ArrowAppender::FinalizeChild(LogicalType::VARCHAR, *append_data.child_data[0]);
+		result->dictionary = &append_data.dictionary;
+		append_data.dictionary =
+		    *ArrowAppender::FinalizeChild(LogicalType::VARCHAR, std::move(append_data.child_data[0]));
 	}
 };
 

package/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp

@@ -28,9 +28,10 @@ public:
 
 public:
 	static void ReleaseArray(ArrowArray *array);
-	static ArrowArray *FinalizeChild(const LogicalType &type, ArrowAppendData &append_data);
+	static ArrowArray *FinalizeChild(const LogicalType &type, unique_ptr<ArrowAppendData> append_data);
 	static unique_ptr<ArrowAppendData> InitializeChild(const LogicalType &type, idx_t capacity,
 	                                                   ClientProperties &options);
+	static void AddChildren(ArrowAppendData &data, idx_t count);
 
 private:
 	//! The types of the chunks that will be appended in

package/src/duckdb/src/include/duckdb/common/arrow/arrow_wrapper.hpp

@@ -35,6 +35,9 @@ public:
 		arrow_array.length = 0;
 		arrow_array.release = nullptr;
 	}
+	ArrowArrayWrapper(ArrowArrayWrapper &&other) : arrow_array(other.arrow_array) {
+		other.arrow_array.release = nullptr;
+	}
 	~ArrowArrayWrapper();
 };
 

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

@@ -97,6 +97,7 @@ public:
 	DUCKDB_API const string &RawMessage() const;
 
 	DUCKDB_API static string ExceptionTypeToString(ExceptionType type);
+	DUCKDB_API static ExceptionType StringToExceptionType(const string &type);
 	[[noreturn]] DUCKDB_API static void ThrowAsTypeWithMessage(ExceptionType type, const string &message,
 	                                                           const std::shared_ptr<Exception> &original);
 	virtual std::shared_ptr<Exception> Copy() const {

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

@@ -18,9 +18,7 @@ public:
 	//! Not initialized, default constructor
 	DUCKDB_API PreservedError();
 	//! From std::exception
-	PreservedError(const std::exception &ex)
-	    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(ex.what())),
-	      exception_instance(nullptr) {
+	PreservedError(const std::exception &ex) : PreservedError(ex.what()) {
 	}
 	//! From a raw string
 	DUCKDB_API explicit PreservedError(const string &raw_message);

package/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp

@@ -33,7 +33,7 @@ struct ExpressionState {
 
 public:
 	void AddChild(Expression *expr);
-	void Finalize();
+	void Finalize(bool empty = false);
 	Allocator &GetAllocator();
 	bool HasContext();
 	DUCKDB_API ClientContext &GetContext();

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/base_csv_reader.hpp

@@ -51,13 +51,9 @@ public:
 	bool linenr_estimated = false;
 
 	bool row_empty = false;
-	idx_t sample_chunk_idx = 0;
-	bool jumping_samples = false;
-	bool end_of_file_reached = false;
 	bool bom_checked = false;
 
 	idx_t bytes_in_chunk = 0;
-	double bytes_per_line_avg = 0;
 
 	DataChunk parse_chunk;
 

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_sniffer.hpp

@@ -34,9 +34,9 @@ public:
 	//! CSV Sniffing consists of five steps:
 	//! 1. Dialect Detection: Generate the CSV Options (delimiter, quote, escape, etc.)
 	//! 2. Type Detection: Figures out the types of the columns (For one chunk)
-	//! 3. Header Detection: Figures out if  the CSV file has a header and produces the names of the columns
-	//! 4. Type Replacement: Replaces the types of the columns if the user specified them
-	//! 5. Type Refinement: Refines the types of the columns for the remaining chunks
+	//! 3. Type Refinement: Refines the types of the columns for the remaining chunks
+	//! 4. Header Detection: Figures out if  the CSV file has a header and produces the names of the columns
+	//! 5. Type Replacement: Replaces the types of the columns if the user specified them
 	SnifferResult SniffCSV();
 
 private:
@@ -107,6 +107,13 @@ private:
 	idx_t best_start_without_header = 0;
 	vector<Value> best_header_row;
 
+	//! ------------------------------------------------------//
+	//! ------------------ Type Refinement ------------------ //
+	//! ------------------------------------------------------//
+	void RefineTypes();
+	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type);
+	vector<LogicalType> detected_types;
+
 	//! ------------------------------------------------------//
 	//! ------------------ Header Detection ----------------- //
 	//! ------------------------------------------------------//
@@ -119,13 +126,6 @@ private:
 	//! ------------------ Type Replacement ----------------- //
 	//! ------------------------------------------------------//
 	void ReplaceTypes();
-
-	//! ------------------------------------------------------//
-	//! ------------------ Type Refinement ------------------ //
-	//! ------------------------------------------------------//
-	void RefineTypes();
-	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type);
-	vector<LogicalType> detected_types;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/replacement_scan.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/string_util.hpp"
 
 namespace duckdb {
 
@@ -30,6 +31,25 @@ struct ReplacementScan {
 	    : function(function), data(std::move(data_p)) {
 	}
 
+	static bool CanReplace(const string &table_name, const vector<string> &extensions) {
+		auto lower_name = StringUtil::Lower(table_name);
+
+		if (StringUtil::EndsWith(lower_name, ".gz")) {
+			lower_name = lower_name.substr(0, lower_name.size() - 3);
+		} else if (StringUtil::EndsWith(lower_name, ".zst")) {
+			lower_name = lower_name.substr(0, lower_name.size() - 4);
+		}
+
+		for (auto &extension : extensions) {
+			if (StringUtil::EndsWith(lower_name, "." + extension) ||
+			    StringUtil::Contains(lower_name, "." + extension + "?")) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 	replacement_scan_t function;
 	unique_ptr<ReplacementScanData> data;
 };

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

@@ -240,6 +240,8 @@ public:
 	DUCKDB_API void SetOption(const string &name, Value value);
 	DUCKDB_API void ResetOption(const string &name);
 
+	DUCKDB_API void CheckLock(const string &name);
+
 	DUCKDB_API static idx_t ParseMemoryLimit(const string &arg);
 
 	//! Return the list of possible compression functions for the specific physical type

package/src/duckdb/src/include/duckdb/optimizer/filter_pushdown.hpp

@@ -43,6 +43,8 @@ private:
 
 	//! Push down a LogicalAggregate op
 	unique_ptr<LogicalOperator> PushdownAggregate(unique_ptr<LogicalOperator> op);
+	//! Push down a distinct operator
+	unique_ptr<LogicalOperator> PushdownDistinct(unique_ptr<LogicalOperator> op);
 	//! Push down a LogicalFilter op
 	unique_ptr<LogicalOperator> PushdownFilter(unique_ptr<LogicalOperator> op);
 	//! Push down a LogicalCrossProduct op

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -362,6 +362,7 @@ private:
 
 	//! If only a schema name is provided (e.g. "a.b") then figure out if "a" is a schema or a catalog name
 	void BindSchemaOrCatalog(string &catalog_name, string &schema_name);
+	const string BindCatalog(string &catalog_name);
 	SchemaCatalogEntry &BindCreateSchema(CreateInfo &info);
 
 	unique_ptr<BoundQueryNode> BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);

package/src/duckdb/src/include/duckdb/planner/bound_parameter_map.hpp

@@ -35,6 +35,9 @@ public:
 
 	unique_ptr<BoundParameterExpression> BindParameterExpression(ParameterExpression &expr);
 
+	//! Flag to indicate that we need to rebind this prepared statement before execution
+	bool rebind = false;
+
 private:
 	shared_ptr<BoundParameterData> CreateOrGetData(const string &identifier);
 	void CreateNewParameter(const string &id, const shared_ptr<BoundParameterData> &param_data);

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -90,8 +90,8 @@ public:
 	void QualifyColumnNames(unique_ptr<ParsedExpression> &expr);
 	static void QualifyColumnNames(Binder &binder, unique_ptr<ParsedExpression> &expr);
 
-	static unique_ptr<Expression> PushCollation(ClientContext &context, unique_ptr<Expression> source,
-	                                            const string &collation, bool equality_only = false);
+	static bool PushCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type,
+	                          bool equality_only = false);
 	static void TestCollation(ClientContext &context, const string &collation);
 
 	bool BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr);

package/src/duckdb/src/main/capi/arrow-c.cpp

@@ -64,7 +64,7 @@ duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared, du
 	if (result_schema->release) {
 		// Need to release the existing schema before we overwrite it
 		result_schema->release(result_schema);
-		result_schema->release = nullptr;
+		D_ASSERT(!result_schema->release);
 	}
 
 	ArrowConverter::ToArrowSchema(result_schema, prepared_types, prepared_names, properties);
@@ -155,14 +155,17 @@ struct PrivateData {
 
 // LCOV_EXCL_START
 // This function is never called, but used to set ArrowSchema's release functions to a non-null NOOP.
-void EmptySchemaRelease(ArrowSchema *) {
+void EmptySchemaRelease(ArrowSchema *schema) {
+	schema->release = nullptr;
 }
 // LCOV_EXCL_STOP
 
-void EmptyArrayRelease(ArrowArray *) {
+void EmptyArrayRelease(ArrowArray *array) {
+	array->release = nullptr;
 }
 
-void EmptyStreamRelease(ArrowArrayStream *) {
+void EmptyStreamRelease(ArrowArrayStream *stream) {
+	stream->release = nullptr;
 }
 
 void FactoryGetSchema(uintptr_t stream_factory_ptr, duckdb::ArrowSchemaWrapper &schema) {

package/src/duckdb/src/main/config.cpp

@@ -233,6 +233,20 @@ void DBConfig::SetDefaultMaxMemory() {
 	}
 }
 
+void DBConfig::CheckLock(const string &name) {
+	if (!options.lock_configuration) {
+		// not locked
+		return;
+	}
+	case_insensitive_set_t allowed_settings {"schema", "search_path"};
+	if (allowed_settings.find(name) != allowed_settings.end()) {
+		// we are always allowed to change these settings
+		return;
+	}
+	// not allowed!
+	throw InvalidInputException("Cannot change configuration option \"%s\" - the configuration has been locked", name);
+}
+
 idx_t CGroupBandwidthQuota(idx_t physical_cores, FileSystem &fs) {
 	static constexpr const char *CPU_MAX = "/sys/fs/cgroup/cpu.max";
 	static constexpr const char *CFS_QUOTA = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us";

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -208,18 +208,20 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		fs.RemoveFile(temp_path);
 	}
 	auto is_http_url = StringUtil::Contains(extension, "http://");
-	if (fs.FileExists(extension)) {
-		idx_t file_size;
-		auto in_buffer = ReadExtensionFileFromDisk(fs, extension, file_size);
-		WriteExtensionFileToDisk(fs, temp_path, in_buffer.get(), file_size);
-
-		if (fs.FileExists(local_extension_path) && force_install) {
-			fs.RemoveFile(local_extension_path);
+	if (ExtensionHelper::IsFullPath(extension)) {
+		if (fs.FileExists(extension)) {
+			idx_t file_size;
+			auto in_buffer = ReadExtensionFileFromDisk(fs, extension, file_size);
+			WriteExtensionFileToDisk(fs, temp_path, in_buffer.get(), file_size);
+
+			if (fs.FileExists(local_extension_path) && force_install) {
+				fs.RemoveFile(local_extension_path);
+			}
+			fs.MoveFile(temp_path, local_extension_path);
+			return;
+		} else if (!is_http_url) {
+			throw IOException("Failed to read extension from \"%s\": no such file", extension);
 		}
-		fs.MoveFile(temp_path, local_extension_path);
-		return;
-	} else if (StringUtil::Contains(extension, "/") && !is_http_url) {
-		throw IOException("Failed to read extension from \"%s\": no such file", extension);
 	}
 
 #ifdef DISABLE_DUCKDB_REMOTE_INSTALL
@@ -280,7 +282,7 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		// create suggestions
 		string message;
 		auto exact_match = ExtensionHelper::CreateSuggestions(extension_name, message);
-		if (exact_match) {
+		if (exact_match && !IsRelease(DuckDB::LibraryVersion())) {
 			message += "\nAre you using a development build? In this case, extensions might not (yet) be uploaded.";
 		}
 		if (res.error() == duckdb_httplib::Error::Success) {

package/src/duckdb/src/optimizer/filter_pushdown.cpp

@@ -33,6 +33,7 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 	case LogicalOperatorType::LOGICAL_UNION:
 		return PushdownSetOperation(std::move(op));
 	case LogicalOperatorType::LOGICAL_DISTINCT:
+		return PushdownDistinct(std::move(op));
 	case LogicalOperatorType::LOGICAL_ORDER_BY: {
 		// we can just push directly through these operations without any rewriting
 		op->children[0] = Rewrite(std::move(op->children[0]));

package/src/duckdb/src/optimizer/pushdown/pushdown_distinct.cpp

@@ -0,0 +1,19 @@
+#include "duckdb/optimizer/filter_pushdown.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/operator/logical_distinct.hpp"
+
+namespace duckdb {
+
+unique_ptr<LogicalOperator> FilterPushdown::PushdownDistinct(unique_ptr<LogicalOperator> op) {
+	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_DISTINCT);
+	auto &distinct = op->Cast<LogicalDistinct>();
+	if (!distinct.order_by) {
+		// regular DISTINCT - can just push down
+		op->children[0] = Rewrite(std::move(op->children[0]));
+		return op;
+	}
+	// no pushdown through DISTINCT ON (yet?)
+	return FinishPushdown(std::move(op));
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/transform/statement/transform_copy.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/core_functions/scalar/struct_functions.hpp"
+#include "duckdb/function/replacement_scan.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
@@ -82,9 +83,10 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGCopySt
 		// copy to a file
 		info.file_path = stmt.filename;
 	}
-	if (StringUtil::EndsWith(info.file_path, ".parquet")) {
+
+	if (ReplacementScan::CanReplace(info.file_path, {"parquet"})) {
 		info.format = "parquet";
-	} else if (StringUtil::EndsWith(info.file_path, ".json") || StringUtil::EndsWith(info.file_path, ".ndjson")) {
+	} else if (ReplacementScan::CanReplace(info.file_path, {"json", "jsonl", "ndjson"})) {
 		info.format = "json";
 	} else {
 		info.format = "csv";

package/src/duckdb/src/parser/transform/statement/transform_create_sequence.cpp

@@ -17,6 +17,8 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 	info->name = qname.name;
 
 	if (stmt.options) {
+		int64_t default_start_value = info->start_value;
+		bool has_start_value = false;
 		unordered_set<SequenceInfo, EnumClassHash> used;
 		duckdb_libpgquery::PGListCell *cell = nullptr;
 		for_each_cell(cell, stmt.options->head) {
@@ -51,10 +53,10 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 					throw ParserException("Increment must not be zero");
 				}
 				if (info->increment < 0) {
-					info->start_value = info->max_value = -1;
+					default_start_value = info->max_value = -1;
 					info->min_value = NumericLimits<int64_t>::Minimum();
 				} else {
-					info->start_value = info->min_value = 1;
+					default_start_value = info->min_value = 1;
 					info->max_value = NumericLimits<int64_t>::Maximum();
 				}
 			} else if (opt_name == "minvalue") {
@@ -68,7 +70,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 
 				info->min_value = opt_value;
 				if (info->increment > 0) {
-					info->start_value = info->min_value;
+					default_start_value = info->min_value;
 				}
 			} else if (opt_name == "maxvalue") {
 				if (used.find(SequenceInfo::SEQ_MAX) != used.end()) {
@@ -81,7 +83,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 
 				info->max_value = opt_value;
 				if (info->increment < 0) {
-					info->start_value = info->max_value;
+					default_start_value = info->max_value;
 				}
 			} else if (opt_name == "start") {
 				if (used.find(SequenceInfo::SEQ_START) != used.end()) {
@@ -91,7 +93,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 				if (nodef) {
 					continue;
 				}
-
+				has_start_value = true;
 				info->start_value = opt_value;
 			} else if (opt_name == "cycle") {
 				if (used.find(SequenceInfo::SEQ_CYCLE) != used.end()) {
@@ -107,6 +109,9 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 				throw ParserException("Unrecognized option \"%s\" for CREATE SEQUENCE", opt_name);
 			}
 		}
+		if (!has_start_value) {
+			info->start_value = default_start_value;
+		}
 	}
 	info->temporary = !stmt.sequence->relpersistence;
 	info->on_conflict = TransformOnConflict(stmt.onconflict);

package/src/duckdb/src/planner/binder/expression/bind_between_expression.cpp

@@ -34,13 +34,11 @@ BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth
 	input = BoundCastExpression::AddCastToType(context, std::move(input), input_type);
 	lower = BoundCastExpression::AddCastToType(context, std::move(lower), input_type);
 	upper = BoundCastExpression::AddCastToType(context, std::move(upper), input_type);
-	if (input_type.id() == LogicalTypeId::VARCHAR) {
-		// handle collation
-		auto collation = StringType::GetCollation(input_type);
-		input = PushCollation(context, std::move(input), collation, false);
-		lower = PushCollation(context, std::move(lower), collation, false);
-		upper = PushCollation(context, std::move(upper), collation, false);
-	}
+	// handle collation
+	PushCollation(context, input, input_type, false);
+	PushCollation(context, lower, input_type, false);
+	PushCollation(context, upper, input_type, false);
+
 	if (!input->HasSideEffects() && !input->HasParameter() && !input->HasSubquery()) {
 		// the expression does not have side effects and can be copied: create two comparisons
 		// the reason we do this is that individual comparisons are easier to handle in optimizers

package/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp

@@ -18,8 +18,10 @@ BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth
 		throw BinderException("collations are only supported for type varchar");
 	}
 	// Validate the collation, but don't use it
-	PushCollation(context, child->Copy(), expr.collation, false);
-	child->return_type = LogicalType::VARCHAR_COLLATION(expr.collation);
+	auto child_copy = child->Copy();
+	auto collation_type = LogicalType::VARCHAR_COLLATION(expr.collation);
+	PushCollation(context, child_copy, collation_type, false);
+	child->return_type = collation_type;
 	return BindResult(std::move(child));
 }