duckdb 0.8.2-dev4871.0 → 0.8.2-dev5080.0

package/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp

@@ -343,8 +343,8 @@ void PhysicalHashAggregate::SinkDistinct(ExecutionContext &context, DataChunk &c
 
 SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, DataChunk &chunk,
                                            OperatorSinkInput &input) const {
-	auto &llstate = input.local_state.Cast<HashAggregateLocalSinkState>();
-	auto &gstate = input.global_state.Cast<HashAggregateGlobalSinkState>();
+	auto &local_state = input.local_state.Cast<HashAggregateLocalSinkState>();
+	auto &global_state = input.global_state.Cast<HashAggregateGlobalSinkState>();
 
 	if (distinct_collection_info) {
 		SinkDistinct(context, chunk, input);
@@ -354,8 +354,7 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, DataChunk
 		return SinkResultType::NEED_MORE_INPUT;
 	}
 
-	DataChunk &aggregate_input_chunk = llstate.aggregate_input_chunk;
-
+	DataChunk &aggregate_input_chunk = local_state.aggregate_input_chunk;
 	auto &aggregates = grouped_aggregate_data.aggregates;
 	idx_t aggregate_input_idx = 0;
 
@@ -385,10 +384,11 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, DataChunk
 
 	// For every grouping set there is one radix_table
 	for (idx_t i = 0; i < groupings.size(); i++) {
-		auto &grouping_gstate = gstate.grouping_states[i];
-		auto &grouping_lstate = llstate.grouping_states[i];
+		auto &grouping_local_state = global_state.grouping_states[i];
+		auto &grouping_global_state = local_state.grouping_states[i];
 		InterruptState interrupt_state;
-		OperatorSinkInput sink_input {*grouping_gstate.table_state, *grouping_lstate.table_state, interrupt_state};
+		OperatorSinkInput sink_input {*grouping_local_state.table_state, *grouping_global_state.table_state,
+		                              interrupt_state};
 
 		auto &grouping = groupings[i];
 		auto &table = grouping.table_data;

package/src/duckdb/src/execution/operator/csv_scanner/csv_reader_options.cpp

@@ -437,7 +437,7 @@ void CSVReaderOptions::FromNamedParameters(named_parameter_map_t &in, ClientCont
 			}
 			sql_type_list.reserve(sql_type_names.size());
 			for (auto &sql_type : sql_type_names) {
-				auto def_type = TransformStringToLogicalType(sql_type);
+				auto def_type = TransformStringToLogicalType(sql_type, context);
 				if (def_type.id() == LogicalTypeId::USER) {
 					throw BinderException("Unrecognized type \"%s\" for read_csv_auto %s definition", sql_type,
 					                      kv.first);

package/src/duckdb/src/execution/operator/csv_scanner/parallel_csv_reader.cpp

@@ -335,8 +335,6 @@ normal : {
 		if (c == options.dialect_options.state_machine_options.delimiter) {
 			// delimiter: end the value and add it to the chunk
 			goto add_value;
-		} else if (c == options.dialect_options.state_machine_options.quote && try_add_line) {
-			return false;
 		} else if (StringUtil::CharacterIsNewline(c)) {
 			// newline: add row
 			if (column > 0 || try_add_line || parse_chunk.data.size() == 1) {

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

@@ -141,6 +141,10 @@ struct SniffValue {
 		     (current_char == '\r' || current_char == '\n')) ||
 		    (machine.dialect_options.new_line == NewLineIdentifier::CARRY_ON && current_char == '\n')) {
 			machine.rows_read++;
+		}
+
+		if ((machine.previous_state == CSVState::RECORD_SEPARATOR && machine.state != CSVState::EMPTY_LINE) ||
+		    (machine.state != CSVState::RECORD_SEPARATOR && machine.previous_state == CSVState::CARRIAGE_RETURN)) {
 			sniffed_values[machine.cur_rows].position = machine.line_start_pos;
 			sniffed_values[machine.cur_rows].set = true;
 			machine.line_start_pos = current_pos;
@@ -287,11 +291,15 @@ void CSVSniffer::DetectTypes() {
 		candidate->csv_buffer_iterator.Process<SniffValue>(*candidate, tuples);
 		// Potentially Skip empty rows (I find this dirty, but it is what the original code does)
 		idx_t true_start = 0;
+		idx_t true_pos = 0;
 		idx_t values_start = 0;
 		while (true_start < tuples.size()) {
 			if (tuples[true_start].values.empty() ||
 			    (tuples[true_start].values.size() == 1 && tuples[true_start].values[0].IsNull())) {
 				true_start = tuples[true_start].line_number;
+				if (true_start < tuples.size()) {
+					true_pos = tuples[true_start].position;
+				}
 				values_start++;
 			} else {
 				break;
@@ -301,7 +309,11 @@ void CSVSniffer::DetectTypes() {
 		// Potentially Skip Notes (I also find this dirty, but it is what the original code does)
 		while (true_start < tuples.size()) {
 			if (tuples[true_start].values.size() < max_columns_found && !options.null_padding) {
+
 				true_start = tuples[true_start].line_number;
+				if (true_start < tuples.size()) {
+					true_pos = tuples[true_start].position;
+				}
 				values_start++;
 			} else {
 				break;
@@ -317,7 +329,7 @@ void CSVSniffer::DetectTypes() {
 			row_idx = 1;
 		}
 		if (!tuples.empty()) {
-			best_start_without_header = tuples[0].position;
+			best_start_without_header = tuples[0].position - true_pos;
 		}
 
 		// First line where we start our type detection
@@ -387,7 +399,7 @@ void CSVSniffer::DetectTypes() {
 			best_sql_types_candidates_per_column_idx = info_sql_types_candidates;
 			best_format_candidates = format_candidates;
 			best_header_row = tuples[0].values;
-			best_start_with_header = tuples[0].position;
+			best_start_with_header = tuples[0].position - true_pos;
 		}
 	}
 	// Assert that it's all good at this point.

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

@@ -59,7 +59,7 @@ static void WriteCopyStatement(FileSystem &fs, stringstream &ss, CopyInfo &info,
 	if (info.format == "csv") {
 		// insert default csv options, if not specified
 		if (info.options.find("header") == info.options.end()) {
-			info.options["header"].push_back(Value::INTEGER(0));
+			info.options["header"].push_back(Value::INTEGER(1));
 		}
 		if (info.options.find("delimiter") == info.options.end() && info.options.find("sep") == info.options.end() &&
 		    info.options.find("delim") == info.options.end()) {

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -184,19 +184,21 @@ static bool PlanIndexJoin(ClientContext &context, LogicalComparisonJoin &op, uni
 	if (!index) {
 		return false;
 	}
-	// index joins are not supported if there are pushed down table filters
-	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
-	auto &tbl_scan = right->Cast<PhysicalTableScan>();
-	//	if (tbl_scan.table_filters && !tbl_scan.table_filters->filters.empty()) {
-	//		return false;
-	//	}
+
 	// index joins are disabled if enable_optimizer is false
 	if (!ClientConfig::GetConfig(context).enable_optimizer) {
 		return false;
 	}
+
+	// index joins are disabled on default
+	auto force_index_join = ClientConfig::GetConfig(context).force_index_join;
+	if (!ClientConfig::GetConfig(context).enable_index_join && !force_index_join) {
+		return false;
+	}
+
 	// check if the cardinality difference justifies an index join
-	if (!((ClientConfig::GetConfig(context).force_index_join ||
-	       left->estimated_cardinality < 0.01 * right->estimated_cardinality))) {
+	auto index_join_is_applicable = left->estimated_cardinality < 0.01 * right->estimated_cardinality;
+	if (!index_join_is_applicable && !force_index_join) {
 		return false;
 	}
 
@@ -205,6 +207,9 @@ static bool PlanIndexJoin(ClientContext &context, LogicalComparisonJoin &op, uni
 		swap(op.conditions[0].left, op.conditions[0].right);
 		swap(op.left_projection_map, op.right_projection_map);
 	}
+	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
+	auto &tbl_scan = right->Cast<PhysicalTableScan>();
+
 	plan = make_uniq<PhysicalIndexJoin>(op, std::move(left), std::move(right), std::move(op.conditions), op.join_type,
 	                                    op.left_projection_map, op.right_projection_map, tbl_scan.column_ids, *index,
 	                                    !swap_condition, op.estimated_cardinality);

package/src/duckdb/src/function/cast/struct_cast.cpp

@@ -9,10 +9,18 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 	vector<BoundCastInfo> child_cast_info;
 	auto &source_child_types = StructType::GetChildTypes(source);
 	auto &result_child_types = StructType::GetChildTypes(target);
+
+	auto target_is_unnamed = StructType::IsUnnamed(target);
+	auto source_is_unnamed = StructType::IsUnnamed(source);
+
 	if (source_child_types.size() != result_child_types.size()) {
 		throw TypeMismatchException(source, target, "Cannot cast STRUCTs of different size");
 	}
 	for (idx_t i = 0; i < source_child_types.size(); i++) {
+		if (!target_is_unnamed && !source_is_unnamed &&
+		    !StringUtil::CIEquals(source_child_types[i].first, result_child_types[i].first)) {
+			throw TypeMismatchException(source, target, "Cannot cast STRUCTs with different names");
+		}
 		auto child_cast = input.GetCastFunction(source_child_types[i].second, result_child_types[i].second);
 		child_cast_info.push_back(std::move(child_cast));
 	}

package/src/duckdb/src/function/cast/time_casts.cpp

@@ -134,6 +134,10 @@ BoundCastInfo DefaultCasts::TimestampMsCastSwitch(BindCastInput &input, const Lo
 		// timestamp (ms) to timestamp (us)
 		return BoundCastInfo(
 		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToUs>);
+	case LogicalTypeId::TIMESTAMP_NS:
+		// timestamp (ms) to timestamp (ns)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToNs>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -146,10 +150,18 @@ BoundCastInfo DefaultCasts::TimestampSecCastSwitch(BindCastInput &input, const L
 	case LogicalTypeId::VARCHAR:
 		// timestamp (sec) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampSec>);
+	case LogicalTypeId::TIMESTAMP_MS:
+		// timestamp (s) to timestamp (ms)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToMs>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp (s) to timestamp (us)
 		return BoundCastInfo(
 		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToUs>);
+	case LogicalTypeId::TIMESTAMP_NS:
+		// timestamp (s) to timestamp (ns)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToNs>);
 	default:
 		return TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/union_casts.cpp

@@ -304,6 +304,11 @@ static bool UnionToVarcharCast(Vector &source, Vector &result, idx_t count, Cast
 	// now construct the actual varchar vector
 	varchar_union.Flatten(count);
 	auto &tag_vector = UnionVector::GetTags(source);
+	auto tag_vector_type = tag_vector.GetVectorType();
+	if (tag_vector_type != VectorType::CONSTANT_VECTOR && tag_vector_type != VectorType::FLAT_VECTOR) {
+		tag_vector.Flatten(count);
+	}
+
 	auto tags = FlatVector::GetData<union_tag_t>(tag_vector);
 
 	auto &validity = FlatVector::Validity(varchar_union);

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

@@ -268,8 +268,17 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
 
 	if (bound_function.null_handling == FunctionNullHandling::DEFAULT_NULL_HANDLING) {
 		for (auto &child : children) {
-			if (child->return_type == LogicalTypeId::SQLNULL ||
-			    (child->IsFoldable() && ExpressionExecutor::EvaluateScalar(context, *child).IsNull())) {
+			if (child->return_type == LogicalTypeId::SQLNULL) {
+				return make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL));
+			}
+			if (!child->IsFoldable()) {
+				continue;
+			}
+			Value result;
+			if (!ExpressionExecutor::TryEvaluateScalar(context, *child, result)) {
+				continue;
+			}
+			if (result.IsNull()) {
 				return make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL));
 			}
 		}

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

@@ -80,6 +80,10 @@ static void PragmaEnableForceParallelism(ClientContext &context, const FunctionP
 	ClientConfig::GetConfig(context).verify_parallelism = true;
 }
 
+static void PragmaEnableIndexJoin(ClientContext &context, const FunctionParameters &parameters) {
+	ClientConfig::GetConfig(context).enable_index_join = true;
+}
+
 static void PragmaEnableForceIndexJoin(ClientContext &context, const FunctionParameters &parameters) {
 	ClientConfig::GetConfig(context).force_index_join = true;
 }
@@ -140,6 +144,7 @@ void PragmaFunctions::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaStatement("enable_optimizer", PragmaEnableOptimizer));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_optimizer", PragmaDisableOptimizer));
 
+	set.AddFunction(PragmaFunction::PragmaStatement("enable_index_join", PragmaEnableIndexJoin));
 	set.AddFunction(PragmaFunction::PragmaStatement("force_index_join", PragmaEnableForceIndexJoin));
 	set.AddFunction(PragmaFunction::PragmaStatement("force_checkpoint", PragmaForceCheckpoint));
 

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

@@ -124,12 +124,15 @@ string PragmaShow(ClientContext &context, const FunctionParameters &parameters)
 	ON cols.column_name = pragma_table_info.name 
 	AND cols.table_name='%table_name%'
 	AND cols.schema_name='%table_schema%'
+	AND cols.database_name = '%table_database%'
 	ORDER BY column_index;)";
 	// 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);
+	sql = StringUtil::Replace(sql, "%table_database%",
+	                          table.catalog.empty() ? DatabaseManager::GetDefaultDatabase(context) : table.catalog);
 	return sql;
 }
 

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

@@ -26,6 +26,8 @@ idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
 	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
 	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
 		return 2;
+	case StrTimeSpecifier::NANOSECOND_PADDED:
+		return 9;
 	case StrTimeSpecifier::MICROSECOND_PADDED:
 		return 6;
 	case StrTimeSpecifier::MILLISECOND_PADDED:
@@ -183,9 +185,15 @@ char *StrfTimeFormat::WritePadded3(char *target, uint32_t value) {
 	}
 }
 
-// write a value in the range of 0..999999 padded to 6 digits
+// write a value in the range of 0..999999... padded to the given number of digits
 char *StrfTimeFormat::WritePadded(char *target, uint32_t value, size_t padding) {
-	D_ASSERT(padding % 2 == 0);
+	D_ASSERT(padding > 1);
+	if (padding % 2) {
+		int decimals = value % 1000;
+		WritePadded3(target + padding - 3, decimals);
+		value /= 1000;
+		padding -= 3;
+	}
 	for (size_t i = 0; i < padding / 2; i++) {
 		int decimals = value % 100;
 		WritePadded2(target + padding - 2 * (i + 1), decimals);
@@ -309,11 +317,14 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 	case StrTimeSpecifier::SECOND_PADDED:
 		target = WritePadded2(target, data[5]);
 		break;
+	case StrTimeSpecifier::NANOSECOND_PADDED:
+		target = WritePadded(target, data[6] * Interval::NANOS_PER_MICRO, 9);
+		break;
 	case StrTimeSpecifier::MICROSECOND_PADDED:
 		target = WritePadded(target, data[6], 6);
 		break;
 	case StrTimeSpecifier::MILLISECOND_PADDED:
-		target = WritePadded3(target, data[6] / 1000);
+		target = WritePadded3(target, data[6] / Interval::MICROS_PER_MSEC);
 		break;
 	case StrTimeSpecifier::UTC_OFFSET: {
 		*target++ = (data[7] < 0) ? '-' : '+';
@@ -516,6 +527,9 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 				case 'S':
 					specifier = StrTimeSpecifier::SECOND_PADDED;
 					break;
+				case 'n':
+					specifier = StrTimeSpecifier::NANOSECOND_PADDED;
+					break;
 				case 'f':
 					specifier = StrTimeSpecifier::MICROSECOND_PADDED;
 					break;
@@ -660,6 +674,8 @@ int StrpTimeFormat::NumericSpecifierWidth(StrTimeSpecifier specifier) {
 		return 4;
 	case StrTimeSpecifier::MICROSECOND_PADDED:
 		return 6;
+	case StrTimeSpecifier::NANOSECOND_PADDED:
+		return 9;
 	default:
 		return -1;
 	}
@@ -855,15 +871,20 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
 				// seconds
 				result_data[5] = number;
 				break;
+			case StrTimeSpecifier::NANOSECOND_PADDED:
+				D_ASSERT(number < Interval::NANOS_PER_SEC); // enforced by the length of the number
+				// microseconds (rounded)
+				result_data[6] = (number + Interval::NANOS_PER_MICRO / 2) / Interval::NANOS_PER_MICRO;
+				break;
 			case StrTimeSpecifier::MICROSECOND_PADDED:
-				D_ASSERT(number < 1000000ULL); // enforced by the length of the number
-				// milliseconds
+				D_ASSERT(number < Interval::MICROS_PER_SEC); // enforced by the length of the number
+				// microseconds
 				result_data[6] = number;
 				break;
 			case StrTimeSpecifier::MILLISECOND_PADDED:
-				D_ASSERT(number < 1000ULL); // enforced by the length of the number
-				// milliseconds
-				result_data[6] = number * 1000;
+				D_ASSERT(number < Interval::MSECS_PER_SEC); // enforced by the length of the number
+				// microseconds
+				result_data[6] = number * Interval::MICROS_PER_MSEC;
 				break;
 			case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
 			case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:

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

@@ -237,6 +237,10 @@ void ArrowTableFunction::PopulateArrowTableType(ArrowTableType &arrow_table, Arr
 
 unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
                                                            vector<LogicalType> &return_types, vector<string> &names) {
+	if (input.inputs[0].IsNull() || input.inputs[1].IsNull() || input.inputs[2].IsNull()) {
+		throw BinderException("arrow_scan: pointers cannot be null");
+	}
+
 	auto stream_factory_ptr = input.inputs[0].GetPointer();
 	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();       // NOLINT
 	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer(); // NOLINT

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

@@ -157,6 +157,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, CopyInfo &in
 	}
 
 	bind_data->FinalizeRead(context);
+
 	if (options.auto_detect) {
 		// We must run the sniffer.
 		auto file_handle = BaseCSVReader::OpenCSV(context, options);
@@ -332,7 +333,7 @@ static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &co
 		global_data->WriteData(options.prefix.c_str(), options.prefix.size());
 	}
 
-	if (options.dialect_options.header) {
+	if (!(options.has_header && !options.dialect_options.header)) {
 		MemoryStream stream;
 		// write the header line to the file
 		for (idx_t i = 0; i < csv_data.options.name_list.size(); i++) {

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

@@ -178,7 +178,10 @@ public:
 		current_file_path = files_path_p[0];
 		CSVFileHandle *file_handle_ptr;
 
-		if (!buffer_manager) {
+		if (!buffer_manager || (options.skip_rows_set && options.dialect_options.skip_rows > 0)) {
+			// If our buffers are too small, and we skip too many rows there is a chance things will go over-buffer
+			// for now don't reuse the buffer manager
+			buffer_manager.reset();
 			file_handle = ReadCSV::OpenCSV(current_file_path, options.compression, context);
 			file_handle_ptr = file_handle.get();
 		} else {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev4871"
+#define DUCKDB_VERSION "0.8.2-dev5080"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "5a29c99891"
+#define DUCKDB_SOURCE_ID "e07b94a748"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -182,6 +182,11 @@ struct MultiFileReader {
 			}
 		}
 		for (idx_t r = 0; r < data.union_readers.size(); r++) {
+			if (!data.union_readers[r]) {
+				data.union_readers.erase(data.union_readers.begin() + r);
+				r--;
+				continue;
+			}
 			// check if the union reader should still be read or not
 			auto entry = file_set.find(data.union_readers[r]->GetFileName());
 			if (entry == file_set.end()) {

package/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp

@@ -632,6 +632,13 @@ struct CastTimestampMsToUs {
 	}
 };
 
+struct CastTimestampMsToNs {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIMESTAMP_NS could not be performed!");
+	}
+};
+
 struct CastTimestampNsToUs {
 	template <class SRC, class DST>
 	static inline DST Operation(SRC input) {
@@ -639,6 +646,13 @@ struct CastTimestampNsToUs {
 	}
 };
 
+struct CastTimestampSecToMs {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIMESTAMP_MS could not be performed!");
+	}
+};
+
 struct CastTimestampSecToUs {
 	template <class SRC, class DST>
 	static inline DST Operation(SRC input) {
@@ -646,6 +660,13 @@ struct CastTimestampSecToUs {
 	}
 };
 
+struct CastTimestampSecToNs {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIMESTAMP_NS could not be performed!");
+	}
+};
+
 template <>
 duckdb::timestamp_t CastTimestampUsToMs::Operation(duckdb::timestamp_t input);
 template <>
@@ -655,9 +676,15 @@ duckdb::timestamp_t CastTimestampUsToSec::Operation(duckdb::timestamp_t input);
 template <>
 duckdb::timestamp_t CastTimestampMsToUs::Operation(duckdb::timestamp_t input);
 template <>
+duckdb::timestamp_t CastTimestampMsToNs::Operation(duckdb::timestamp_t input);
+template <>
 duckdb::timestamp_t CastTimestampNsToUs::Operation(duckdb::timestamp_t input);
 template <>
+duckdb::timestamp_t CastTimestampSecToMs::Operation(duckdb::timestamp_t input);
+template <>
 duckdb::timestamp_t CastTimestampSecToUs::Operation(duckdb::timestamp_t input);
+template <>
+duckdb::timestamp_t CastTimestampSecToNs::Operation(duckdb::timestamp_t input);
 
 template <>
 duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_t input, Vector &result);

package/src/duckdb/src/include/duckdb/common/operator/comparison_operators.hpp

@@ -8,11 +8,11 @@
 
 #pragma once
 
-#include "duckdb/common/types/string_type.hpp"
+#include "duckdb/common/helper.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/helper.hpp"
+#include "duckdb/common/types/string_type.hpp"
 
 #include <cstring>
 
@@ -142,6 +142,42 @@ struct DistinctLessThanEquals {
 	}
 };
 
+//===--------------------------------------------------------------------===//
+// Comparison Operator Wrappers (so (Not)DistinctFrom have the same API)
+//===--------------------------------------------------------------------===//
+template <class OP>
+struct ComparisonOperationWrapper {
+	static constexpr const bool COMPARE_NULL = false;
+
+	template <class T>
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		if (right_null || left_null) {
+			return false;
+		}
+		return OP::template Operation<T>(left, right);
+	}
+};
+
+template <>
+struct ComparisonOperationWrapper<DistinctFrom> {
+	static constexpr const bool COMPARE_NULL = true;
+
+	template <class T>
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return DistinctFrom::template Operation<T>(left, right, left_null, right_null);
+	}
+};
+
+template <>
+struct ComparisonOperationWrapper<NotDistinctFrom> {
+	static constexpr const bool COMPARE_NULL = true;
+
+	template <class T>
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return NotDistinctFrom::template Operation<T>(left, right, left_null, right_null);
+	}
+};
+
 //===--------------------------------------------------------------------===//
 // Specialized Boolean Comparison Operators
 //===--------------------------------------------------------------------===//

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

@@ -408,6 +408,7 @@ struct StructType {
 	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type, idx_t index);
 	DUCKDB_API static const string &GetChildName(const LogicalType &type, idx_t index);
 	DUCKDB_API static idx_t GetChildCount(const LogicalType &type);
+	DUCKDB_API static bool IsUnnamed(const LogicalType &type);
 };
 
 struct MapType {

package/src/duckdb/src/include/duckdb/core_functions/scalar/bit_functions.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 struct GetBitFun {
 	static constexpr const char *Name = "get_bit";
 	static constexpr const char *Parameters = "bitstring,index";
-	static constexpr const char *Description = "Extracts the nth bit from bitstring; the first (leftmost) bit is indexed 0.";
+	static constexpr const char *Description = "Extracts the nth bit from bitstring; the first (leftmost) bit is indexed 0";
 	static constexpr const char *Example = "get_bit('0110010'::BIT, 2)";
 
 	static ScalarFunction GetFunction();
@@ -27,7 +27,7 @@ struct GetBitFun {
 struct SetBitFun {
 	static constexpr const char *Name = "set_bit";
 	static constexpr const char *Parameters = "bitstring,index,new_value";
-	static constexpr const char *Description = "Sets the nth bit in bitstring to newvalue; the first (leftmost) bit is indexed 0. Returns a new bitstring.";
+	static constexpr const char *Description = "Sets the nth bit in bitstring to newvalue; the first (leftmost) bit is indexed 0. Returns a new bitstring";
 	static constexpr const char *Example = "set_bit('0110010'::BIT, 2, 0)";
 
 	static ScalarFunction GetFunction();
@@ -36,7 +36,7 @@ struct SetBitFun {
 struct BitPositionFun {
 	static constexpr const char *Name = "bit_position";
 	static constexpr const char *Parameters = "substring,bitstring";
-	static constexpr const char *Description = "Returns first starting index of the specified substring within bits, or zero if it’s not present. The first (leftmost) bit is indexed 1";
+	static constexpr const char *Description = "Returns first starting index of the specified substring within bits, or zero if it is not present. The first (leftmost) bit is indexed 1";
 	static constexpr const char *Example = "bit_position('010'::BIT, '1110101'::BIT)";
 
 	static ScalarFunction GetFunction();
@@ -45,7 +45,7 @@ struct BitPositionFun {
 struct BitStringFun {
 	static constexpr const char *Name = "bitstring";
 	static constexpr const char *Parameters = "bitstring,length";
-	static constexpr const char *Description = "Pads the bitstring until the specified length.";
+	static constexpr const char *Description = "Pads the bitstring until the specified length";
 	static constexpr const char *Example = "bitstring('1010'::BIT, 7)";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/blob_functions.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 struct DecodeFun {
 	static constexpr const char *Name = "decode";
 	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Convert blob to varchar. Fails if blob is not valid utf-8.";
+	static constexpr const char *Description = "Convert blob to varchar. Fails if blob is not valid utf-8";
 	static constexpr const char *Example = "decode('\\xC3\\xBC'::BLOB)";
 
 	static ScalarFunction GetFunction();
@@ -27,7 +27,7 @@ struct DecodeFun {
 struct EncodeFun {
 	static constexpr const char *Name = "encode";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert varchar to blob. Converts utf-8 characters into literal encoding.";
+	static constexpr const char *Description = "Convert varchar to blob. Converts utf-8 characters into literal encoding";
 	static constexpr const char *Example = "encode('my_string_with_ü')";
 
 	static ScalarFunction GetFunction();
@@ -36,7 +36,7 @@ struct EncodeFun {
 struct FromBase64Fun {
 	static constexpr const char *Name = "from_base64";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert a base64 encoded string to a character string.";
+	static constexpr const char *Description = "Convert a base64 encoded string to a character string";
 	static constexpr const char *Example = "from_base64('QQ==')";
 
 	static ScalarFunction GetFunction();
@@ -45,7 +45,7 @@ struct FromBase64Fun {
 struct ToBase64Fun {
 	static constexpr const char *Name = "to_base64";
 	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Convert a blob to a base64 encoded string.";
+	static constexpr const char *Description = "Convert a blob to a base64 encoded string";
 	static constexpr const char *Example = "base64('A'::blob)";
 
 	static ScalarFunction GetFunction();