duckdb 0.8.1-dev355.0 → 0.8.1-dev407.0

package/package.json

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

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -432,7 +432,7 @@ struct ICUDatePart : public ICUDateFunc {
 		throw NotImplementedException("FIXME: serialize icu-datepart");
 	}
 
-	static duckdb::unique_ptr<FunctionData> DeserializeFunction(ClientContext &context, FieldReader &reader,
+	static duckdb::unique_ptr<FunctionData> DeserializeFunction(PlanDeserializationState &state, FieldReader &reader,
 	                                                            ScalarFunction &bound_function) {
 		throw NotImplementedException("FIXME: serialize icu-datepart");
 	}

package/src/duckdb/extension/icu/icu-extension.cpp

@@ -145,7 +145,7 @@ static void ICUCollateSerialize(FieldWriter &writer, const FunctionData *bind_da
 	throw NotImplementedException("FIXME: serialize icu-collate");
 }
 
-static duckdb::unique_ptr<FunctionData> ICUCollateDeserialize(ClientContext &context, FieldReader &reader,
+static duckdb::unique_ptr<FunctionData> ICUCollateDeserialize(PlanDeserializationState &state, FieldReader &reader,
                                                               ScalarFunction &bound_function) {
 	throw NotImplementedException("FIXME: serialize icu-collate");
 }

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -53,7 +53,7 @@ struct ICUStrptime : public ICUDateFunc {
 			throw NotImplementedException("FIXME: serialize icu-strptime");
 		}
 
-		static duckdb::unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+		static duckdb::unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 		                                                    ScalarFunction &bound_function) {
 			throw NotImplementedException("FIXME: serialize icu-strptime");
 		}

package/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.cpp

@@ -1310,10 +1310,8 @@ NumeratorSubstitution::doParse(const UnicodeString& text,
         // compute the 'effective' base and prescale the value down
         int64_t n = result.getLong(status); // force conversion!
         int64_t d = 1;
-        int32_t pow = 0;
         while (d <= n) {
             d *= 10;
-            ++pow;
         }
         // now add the zeros
         while (zeroCount > 0) {

package/src/duckdb/extension/json/include/json_scan.hpp

@@ -292,7 +292,8 @@ public:
 	                                  vector<unique_ptr<Expression>> &filters);
 
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function);
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader, TableFunction &function);
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
+	                                            TableFunction &function);
 
 	static void TableFunctionDefaults(TableFunction &table_function);
 };

package/src/duckdb/extension/json/json_functions/json_contains.cpp

@@ -114,6 +114,11 @@ static void JSONContainsFunction(DataChunk &args, ExpressionState &state, Vector
 	auto &needles = args.data[1];
 
 	if (needles.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		if (ConstantVector::IsNull(needles)) {
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			ConstantVector::SetNull(result, true);
+			return;
+		}
 		auto &needle_str = *ConstantVector::GetData<string_t>(needles);
 		auto needle_doc = JSONCommon::ReadDocument(needle_str, JSONCommon::READ_FLAG, lstate.json_allocator.GetYYAlc());
 		UnaryExecutor::Execute<string_t, bool>(haystacks, result, args.size(), [&](string_t haystack_str) {

package/src/duckdb/extension/json/json_scan.cpp

@@ -962,9 +962,10 @@ void JSONScan::Serialize(FieldWriter &writer, const FunctionData *bind_data_p, c
 	bind_data.Serialize(writer);
 }
 
-unique_ptr<FunctionData> JSONScan::Deserialize(ClientContext &context, FieldReader &reader, TableFunction &function) {
+unique_ptr<FunctionData> JSONScan::Deserialize(PlanDeserializationState &state, FieldReader &reader,
+                                               TableFunction &function) {
 	auto result = make_uniq<JSONScanData>();
-	result->Deserialize(context, reader);
+	result->Deserialize(state.context, reader);
 	return std::move(result);
 }
 

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

@@ -411,8 +411,9 @@ public:
 		bind_data.parquet_options.Serialize(writer);
 	}
 
-	static unique_ptr<FunctionData> ParquetScanDeserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> ParquetScanDeserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                                       TableFunction &function) {
+		auto &context = state.context;
 		auto files = reader.ReadRequiredList<string>();
 		auto types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 		auto names = reader.ReadRequiredList<string>();

package/src/duckdb/src/common/exception_format_value.cpp

@@ -85,10 +85,14 @@ string ExceptionFormatValue::Format(const string &msg, std::vector<ExceptionForm
 		}
 		return duckdb_fmt::vsprintf(msg, duckdb_fmt::basic_format_args<duckdb_fmt::printf_context>(
 		                                     format_args.data(), static_cast<int>(format_args.size())));
-	} catch (std::exception &ex) {
+	} catch (std::exception &ex) { // LCOV_EXCL_START
+		// work-around for oss-fuzz limiting memory which causes issues here
+		if (StringUtil::Contains(ex.what(), "fuzz mode")) {
+			throw Exception(msg);
+		}
 		throw InternalException(std::string("Primary exception: ") + msg +
 		                        "\nSecondary exception in ExceptionFormatValue: " + ex.what());
-	}
+	} // LCOV_EXCL_STOP
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/random_engine.cpp

@@ -28,7 +28,7 @@ double RandomEngine::NextRandom(double min, double max) {
 }
 
 double RandomEngine::NextRandom() {
-	return random_state->pcg() / double(std::numeric_limits<uint32_t>::max());
+	return std::ldexp(random_state->pcg(), -32);
 }
 uint32_t RandomEngine::NextRandomInteger() {
 	return random_state->pcg();

package/src/duckdb/src/common/types/time.cpp

@@ -194,9 +194,7 @@ dtime_t Time::FromTime(int32_t hour, int32_t minute, int32_t second, int32_t mic
 	return dtime_t(result);
 }
 
-// LCOV_EXCL_START
-#ifdef DEBUG
-static bool AssertValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
+bool Time::IsValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
 	if (hour < 0 || hour >= 24) {
 		return false;
 	}
@@ -211,8 +209,6 @@ static bool AssertValidTime(int32_t hour, int32_t minute, int32_t second, int32_
 	}
 	return true;
 }
-#endif
-// LCOV_EXCL_STOP
 
 void Time::Convert(dtime_t dtime, int32_t &hour, int32_t &min, int32_t &sec, int32_t &micros) {
 	int64_t time = dtime.micros;
@@ -223,9 +219,7 @@ void Time::Convert(dtime_t dtime, int32_t &hour, int32_t &min, int32_t &sec, int
 	sec = int32_t(time / Interval::MICROS_PER_SEC);
 	time -= int64_t(sec) * Interval::MICROS_PER_SEC;
 	micros = int32_t(time);
-#ifdef DEBUG
-	D_ASSERT(AssertValidTime(hour, min, sec, micros));
-#endif
+	D_ASSERT(Time::IsValidTime(hour, min, sec, micros));
 }
 
 dtime_t Time::FromTimeMs(int64_t time_ms) {

package/src/duckdb/src/common/types.cpp

@@ -559,6 +559,10 @@ bool LogicalType::GetDecimalProperties(uint8_t &width, uint8_t &scale) const {
 		scale = DecimalType::GetScale(*this);
 		break;
 	default:
+		// Nonsense values to ensure initialization
+		width = 255u;
+		scale = 255u;
+		// FIXME(carlo): This should be probably a throw, requires checkign the various call-sites
 		return false;
 	}
 	return true;

package/src/duckdb/src/core_functions/aggregate/distributive/string_agg.cpp

@@ -147,7 +147,7 @@ static void StringAggSerialize(FieldWriter &writer, const FunctionData *bind_dat
 	writer.WriteString(bind_data.sep);
 }
 
-unique_ptr<FunctionData> StringAggDeserialize(ClientContext &context, FieldReader &reader,
+unique_ptr<FunctionData> StringAggDeserialize(PlanDeserializationState &state, FieldReader &reader,
                                               AggregateFunction &bound_function) {
 	auto sep = reader.ReadRequired<string>();
 	return make_uniq<StringAggBindData>(std::move(sep));

package/src/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp

@@ -42,7 +42,7 @@ struct ApproximateQuantileBindData : public FunctionData {
 		writer.WriteList<float>(bind_data.quantiles);
 	}
 
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            AggregateFunction &bound_function) {
 		auto quantiles = reader.ReadRequiredList<float>();
 		return make_uniq<ApproximateQuantileBindData>(std::move(quantiles));

package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp

@@ -1160,7 +1160,7 @@ static void QuantileSerialize(FieldWriter &writer, const FunctionData *bind_data
 	writer.WriteField<bool>(bind_data->desc);
 }
 
-unique_ptr<FunctionData> QuantileDeserialize(ClientContext &context, FieldReader &reader,
+unique_ptr<FunctionData> QuantileDeserialize(PlanDeserializationState &state, FieldReader &reader,
                                              AggregateFunction &bound_function) {
 	auto quantiles = reader.ReadRequiredSerializableList<Value, Value>();
 	auto bind_data = make_uniq<QuantileBindData>(quantiles);

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -71,7 +71,7 @@ struct ReservoirQuantileBindData : public FunctionData {
 		writer.WriteField<int32_t>(bind_data.sample_size);
 	}
 
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            AggregateFunction &bound_function) {
 		auto quantiles = reader.ReadRequiredList<double>();
 		auto sample_size = reader.ReadRequired<int32_t>();

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -1377,7 +1377,7 @@ struct StructDatePart {
 		writer.WriteList<DatePartSpecifier>(info.part_codes);
 	}
 
-	static unique_ptr<FunctionData> DeserializeFunction(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> DeserializeFunction(PlanDeserializationState &state, FieldReader &reader,
 	                                                    ScalarFunction &bound_function) {
 		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 		auto part_codes = reader.ReadRequiredList<DatePartSpecifier>();

package/src/duckdb/src/core_functions/scalar/date/make_date.cpp

@@ -47,6 +47,9 @@ struct MakeTimeOperator {
 	static RESULT_TYPE Operation(HH hh, MM mm, SS ss) {
 		int64_t secs = ss;
 		int64_t micros = std::round((ss - secs) * Interval::MICROS_PER_SEC);
+		if (!Time::IsValidTime(hh, mm, secs, micros)) {
+			throw ConversionException("Time out of range: %d:%d:%d.%d", hh, mm, secs, micros);
+		}
 		return Time::FromTime(hh, mm, secs, micros);
 	}
 };

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

@@ -28,7 +28,7 @@ template <typename INPUT_TYPE, typename INDEX_TYPE>
 bool ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value) {
 	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
 	if (index < 0) {
-		if (-index > length) {
+		if (index < -length) {
 			return false;
 		}
 		index = length + index;

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -15,6 +15,12 @@ namespace duckdb {
 // FIXME: use a local state for each thread to increase performance?
 // FIXME: benchmark the use of simple_update against using update (if applicable)
 
+static unique_ptr<FunctionData> ListAggregatesBindFailure(ScalarFunction &bound_function) {
+	bound_function.arguments[0] = LogicalType::SQLNULL;
+	bound_function.return_type = LogicalType::SQLNULL;
+	return make_uniq<VariableReturnBindData>(LogicalType::SQLNULL);
+}
+
 struct ListAggregatesBindData : public FunctionData {
 	ListAggregatesBindData(const LogicalType &stype_p, unique_ptr<Expression> aggr_expr_p);
 	~ListAggregatesBindData() override;
@@ -31,11 +37,24 @@ struct ListAggregatesBindData : public FunctionData {
 		return stype == other.stype && aggr_expr->Equals(*other.aggr_expr);
 	}
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-		throw NotImplementedException("FIXME: list aggr serialize");
+		auto bind_data = dynamic_cast<const ListAggregatesBindData *>(bind_data_p);
+		if (!bind_data) {
+			writer.WriteField<bool>(false);
+		} else {
+			writer.WriteField<bool>(true);
+			writer.WriteSerializable(bind_data->stype);
+			writer.WriteSerializable(*bind_data->aggr_expr);
+		}
 	}
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            ScalarFunction &bound_function) {
-		throw NotImplementedException("FIXME: list aggr deserialize");
+		if (reader.ReadRequired<bool>()) {
+			auto s_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+			auto expr = reader.ReadRequiredSerializable<Expression>(state);
+			return make_uniq<ListAggregatesBindData>(s_type, std::move(expr));
+		} else {
+			return ListAggregatesBindFailure(bound_function);
+		}
 	}
 };
 
@@ -396,9 +415,7 @@ template <bool IS_AGGR = false>
 static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
-		bound_function.arguments[0] = LogicalType::SQLNULL;
-		bound_function.return_type = LogicalType::SQLNULL;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+		return ListAggregatesBindFailure(bound_function);
 	}
 
 	bool is_parameter = arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN;

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -24,7 +24,7 @@ public:
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
 		throw NotImplementedException("FIXME: list lambda serialize");
 	}
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            ScalarFunction &bound_function) {
 		throw NotImplementedException("FIXME: list lambda deserialize");
 	}
@@ -328,7 +328,6 @@ static unique_ptr<FunctionData> ListLambdaBind(ClientContext &context, ScalarFun
 	}
 
 	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
-		bound_function.arguments.pop_back();
 		bound_function.arguments[0] = LogicalType::SQLNULL;
 		bound_function.return_type = LogicalType::SQLNULL;
 		return make_uniq<VariableReturnBindData>(bound_function.return_type);

package/src/duckdb/src/core_functions/scalar/math/numeric.cpp

@@ -502,13 +502,13 @@ struct RoundOperatorPrecision {
 	static inline TR Operation(TA input, TB precision) {
 		double rounded_value;
 		if (precision < 0) {
-			double modifier = std::pow(10, -precision);
+			double modifier = std::pow(10, -TA(precision));
 			rounded_value = (std::round(input / modifier)) * modifier;
 			if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
 				return 0;
 			}
 		} else {
-			double modifier = std::pow(10, precision);
+			double modifier = std::pow(10, TA(precision));
 			rounded_value = (std::round(input * modifier)) / modifier;
 			if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
 				return input;
@@ -574,7 +574,7 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt
 	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
-	if (-info.target_scale >= width) {
+	if (info.target_scale <= -int32_t(width)) {
 		// scale too big for width
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		result.SetValue(0, Value::INTEGER(0));

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

@@ -292,6 +292,7 @@ string Leaf::VerifyAndToString(const ART &art, const bool only_verify) const {
 	}
 
 	D_ASSERT(remaining == 0);
+	(void)this_count;
 	D_ASSERT(this_count == count);
 	return only_verify ? "" : "Leaf [count: " + to_string(count) + ", row IDs: " + str + "] \n";
 }

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

@@ -313,6 +313,7 @@ string Node::VerifyAndToString(ART &art, const bool only_verify) {
 		child = GetNextChild(art, byte, false);
 	}
 
+	(void)child_count;
 	// ensure that the child count is at least two
 	D_ASSERT(child_count > 1);
 	return only_verify ? "" : "\n" + str + "]";

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -627,6 +627,8 @@ void ScanStructure::NextMarkJoin(DataChunk &keys, DataChunk &input, DataChunk &r
 		ConstructMarkJoinResult(keys, input, result);
 	} else {
 		auto &info = ht.correlated_mark_join_info;
+		lock_guard<mutex> mj_lock(info.mj_lock);
+
 		// there are correlated columns
 		// first we fetch the counts from the aggregate hashtable corresponding to these entries
 		D_ASSERT(keys.ColumnCount() == info.group_chunk.ColumnCount() + 1);

package/src/duckdb/src/execution/operator/projection/physical_tableinout_function.cpp

@@ -70,6 +70,7 @@ OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 		// we are processing a new row: fetch the data for the current row
+		state.input_chunk.Reset();
 		D_ASSERT(input.ColumnCount() == state.input_chunk.ColumnCount());
 		// set up the input data to the table in-out function
 		for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {

package/src/duckdb/src/execution/operator/projection/physical_unnest.cpp

@@ -65,8 +65,8 @@ void UnnestOperatorState::SetLongestListLength() {
 		if (vector_data.validity.RowIsValid(current_idx)) {
 
 			// check if this list is longer
-			auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(vector_data);
-			auto list_entry = list_data[current_idx];
+			auto list_data_entries = UnifiedVectorFormat::GetData<list_entry_t>(vector_data);
+			auto list_entry = list_data_entries[current_idx];
 			if (list_entry.length > longest_list_length) {
 				longest_list_length = list_entry.length;
 			}
@@ -259,6 +259,11 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
 	auto &state = state_p.Cast<UnnestOperatorState>();
 
 	do {
+		// reset validities, if previous loop iteration contained UNNEST(NULL)
+		if (include_input) {
+			chunk.Reset();
+		}
+
 		// prepare the input data by executing any expressions and getting the
 		// UnifiedVectorFormat of each LIST vector (list_vector_data) and its child vector (list_child_data)
 		if (state.first_fetch) {
@@ -271,7 +276,7 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
-		// each UNNEST in the select_list contains a list (or NULL) for this row, find longest list
+		// each UNNEST in the select_list contains a list (or NULL) for this row, find the longest list
 		// because this length determines how many times we need to repeat for the current row
 		if (state.longest_list_length == DConstants::INVALID_INDEX) {
 			state.SetLongestListLength();

package/src/duckdb/src/execution/reservoir_sample.cpp

@@ -104,10 +104,24 @@ void ReservoirSamplePercentage::AddToReservoir(DataChunk &input) {
 		idx_t append_to_next_sample = input.size() - append_to_current_sample_count;
 		if (append_to_current_sample_count > 0) {
 			// we have elements remaining, first add them to the current sample
-			input.Flatten();
-
-			input.SetCardinality(append_to_current_sample_count);
-			current_sample->AddToReservoir(input);
+			if (append_to_next_sample > 0) {
+				// we need to also add to the next sample
+				DataChunk new_chunk;
+				new_chunk.Initialize(allocator, input.GetTypes());
+				SelectionVector sel(append_to_current_sample_count);
+				for (idx_t r = 0; r < append_to_current_sample_count; r++) {
+					sel.set_index(r, r);
+				}
+				new_chunk.Slice(sel, append_to_current_sample_count);
+				new_chunk.Flatten();
+
+				current_sample->AddToReservoir(new_chunk);
+			} else {
+				input.Flatten();
+
+				input.SetCardinality(append_to_current_sample_count);
+				current_sample->AddToReservoir(input);
+			}
 		}
 		if (append_to_next_sample > 0) {
 			// slice the input for the remainder

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -221,7 +221,7 @@ AggregateFunction CountFun::GetFunction() {
 static void CountStarSerialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
 }
 
-static unique_ptr<FunctionData> CountStarDeserialize(ClientContext &context, FieldReader &reader,
+static unique_ptr<FunctionData> CountStarDeserialize(PlanDeserializationState &state, FieldReader &reader,
                                                      AggregateFunction &function) {
 	return nullptr;
 }

package/src/duckdb/src/function/aggregate/distributive/first.cpp

@@ -297,8 +297,9 @@ template <bool LAST, bool SKIP_NULLS>
 unique_ptr<FunctionData> BindDecimalFirst(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
 	auto decimal_type = arguments[0]->return_type;
+	auto name = std::move(function.name);
 	function = GetFirstFunction<LAST, SKIP_NULLS>(decimal_type);
-	function.name = "first";
+	function.name = std::move(name);
 	function.return_type = decimal_type;
 	return nullptr;
 }

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -519,7 +519,7 @@ struct SortedAggregateFunction {
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
 		throw NotImplementedException("FIXME: serialize sorted aggregate not supported");
 	}
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            AggregateFunction &function) {
 		throw NotImplementedException("FIXME: deserialize sorted aggregate not supported");
 	}

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

@@ -56,7 +56,7 @@ void ListExtractTemplate(idx_t count, UnifiedVectorFormat &list_data, UnifiedVec
 
 		idx_t child_offset;
 		if (offsets_entry < 0) {
-			if ((idx_t)-offsets_entry > list_entry.length) {
+			if (offsets_entry < -int64_t(list_entry.length)) {
 				result_mask.SetInvalid(i);
 				continue;
 			}

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -257,7 +257,7 @@ static void SerializeDecimalArithmetic(FieldWriter &writer, const FunctionData *
 
 // TODO this is partially duplicated from the bind
 template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
-unique_ptr<FunctionData> DeserializeDecimalArithmetic(ClientContext &context, FieldReader &reader,
+unique_ptr<FunctionData> DeserializeDecimalArithmetic(PlanDeserializationState &state, FieldReader &reader,
                                                       ScalarFunction &bound_function) {
 	// re-change the function pointers
 	auto check_overflow = reader.ReadRequired<bool>();

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -274,7 +274,7 @@ static void ExportStateAggregateSerialize(FieldWriter &writer, const FunctionDat
                                           const AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
-static unique_ptr<FunctionData> ExportStateAggregateDeserialize(ClientContext &context, FieldReader &reader,
+static unique_ptr<FunctionData> ExportStateAggregateDeserialize(PlanDeserializationState &state, FieldReader &reader,
                                                                 AggregateFunction &bound_function) {
 	throw NotImplementedException("FIXME: export state deserialize");
 }
@@ -283,7 +283,7 @@ static void ExportStateScalarSerialize(FieldWriter &writer, const FunctionData *
                                        const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
-static unique_ptr<FunctionData> ExportStateScalarDeserialize(ClientContext &context, FieldReader &reader,
+static unique_ptr<FunctionData> ExportStateScalarDeserialize(PlanDeserializationState &state, FieldReader &reader,
                                                              ScalarFunction &bound_function) {
 	throw NotImplementedException("FIXME: export state deserialize");
 }

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

@@ -32,6 +32,9 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 	optional_ptr<AttachedDatabase> db;
 	auto &db_manager = DatabaseManager::Get(context);
 	if (!input.inputs.empty()) {
+		if (input.inputs[0].IsNull()) {
+			throw BinderException("Database cannot be NULL");
+		}
 		auto &db_name = StringValue::Get(input.inputs[0]);
 		db = db_manager.GetDatabase(context, db_name);
 		if (!db) {

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

@@ -1129,7 +1129,7 @@ static void CSVReaderSerialize(FieldWriter &writer, const FunctionData *bind_dat
 	}
 }
 
-static unique_ptr<FunctionData> CSVReaderDeserialize(ClientContext &context, FieldReader &reader,
+static unique_ptr<FunctionData> CSVReaderDeserialize(PlanDeserializationState &state, FieldReader &reader,
                                                      TableFunction &function) {
 	function.extra_info = reader.ReadRequired<string>();
 	auto result_data = make_uniq<ReadCSVData>();

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

@@ -417,7 +417,7 @@ static void TableScanSerialize(FieldWriter &writer, const FunctionData *bind_dat
 	writer.WriteString(bind_data.table.schema.catalog.GetName());
 }
 
-static unique_ptr<FunctionData> TableScanDeserialize(ClientContext &context, FieldReader &reader,
+static unique_ptr<FunctionData> TableScanDeserialize(PlanDeserializationState &state, FieldReader &reader,
                                                      TableFunction &function) {
 	auto schema_name = reader.ReadRequired<string>();
 	auto table_name = reader.ReadRequired<string>();
@@ -426,7 +426,7 @@ static unique_ptr<FunctionData> TableScanDeserialize(ClientContext &context, Fie
 	auto result_ids = reader.ReadRequiredList<row_t>();
 	auto catalog_name = reader.ReadField<string>(INVALID_CATALOG);
 
-	auto &catalog_entry = Catalog::GetEntry<TableCatalogEntry>(context, catalog_name, schema_name, table_name);
+	auto &catalog_entry = Catalog::GetEntry<TableCatalogEntry>(state.context, catalog_name, schema_name, table_name);
 	if (catalog_entry.type != CatalogType::TABLE_ENTRY) {
 		throw SerializationException("Cant find table for %s.%s", schema_name, table_name);
 	}

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.1-dev355"
+#define DUCKDB_VERSION "0.8.1-dev407"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "e9b683ce15"
+#define DUCKDB_SOURCE_ID "01e2ae9e8b"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -42,6 +42,8 @@ public:
 	DUCKDB_API static dtime_t FromTimeMs(int64_t time_ms);
 	DUCKDB_API static dtime_t FromTimeNs(int64_t time_ns);
 
+	DUCKDB_API static bool IsValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds);
+
 private:
 	static bool TryConvertInternal(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict);
 };

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

@@ -49,7 +49,7 @@ typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_m
 
 typedef void (*aggregate_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
                                       const AggregateFunction &function);
-typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(ClientContext &context, FieldReader &reader,
+typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
                                                             AggregateFunction &function);
 
 class AggregateFunction : public BaseScalarFunction {

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

@@ -66,7 +66,7 @@ public:
 				throw SerializationException("Function requires deserialization but no deserialization function for %s",
 				                             function.name);
 			}
-			bind_info = function.deserialize(context, reader, function);
+			bind_info = function.deserialize(state, reader, function);
 		} else {
 			D_ASSERT(!function.serialize);
 			D_ASSERT(!function.deserialize);

package/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp

@@ -68,7 +68,7 @@ struct VariableReturnBindData : public FunctionData {
 		writer.WriteSerializable(info.stype);
 	}
 
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &context, FieldReader &reader,
 	                                            ScalarFunction &bound_function) {
 		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 		return make_uniq<VariableReturnBindData>(std::move(stype));