duckdb 0.3.3-dev835.0 → 0.3.3-dev844.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev835.0",
+  "version": "0.3.3-dev844.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -76299,10 +76299,12 @@ static void ListCombineFunction(Vector &state, Vector &combined, idx_t count) {
 	auto states_ptr = (ListAggState **)sdata.data;
 
 	auto combined_ptr = FlatVector::GetData<ListAggState *>(combined);
-
 	for (idx_t i = 0; i < count; i++) {
 		auto state = states_ptr[sdata.sel->get_index(i)];
-		D_ASSERT(state->list_vector);
+		if (!state->list_vector) {
+			// NULL, no need to append.
+			continue;
+		}
 		if (!combined_ptr[i]->list_vector) {
 			combined_ptr[i]->list_vector = new Vector(state->list_vector->GetType());
 		}
@@ -76320,17 +76322,18 @@ static void ListFinalize(Vector &state_vector, FunctionData *, Vector &result, i
 
 	auto &mask = FlatVector::Validity(result);
 	size_t total_len = ListVector::GetListSize(result);
+
 	for (idx_t i = 0; i < count; i++) {
 		auto state = states[sdata.sel->get_index(i)];
+		const auto rid = i + offset;
 		if (!state->list_vector) {
-			mask.SetInvalid(i);
+			mask.SetInvalid(rid);
 			continue;
 		}
-		D_ASSERT(state->list_vector);
+
 		auto list_struct_data = FlatVector::GetData<list_entry_t>(result);
 		auto &state_lv = *state->list_vector;
 		auto state_lv_count = ListVector::GetListSize(state_lv);
-		const auto rid = i + offset;
 		list_struct_data[rid].length = state_lv_count;
 		list_struct_data[rid].offset = total_len;
 		total_len += state_lv_count;
@@ -90184,17 +90187,75 @@ struct MD5Operator {
 	}
 };
 
+struct MD5Number128Operator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input) {
+		data_t digest[MD5Context::MD5_HASH_LENGTH_BINARY];
+
+		MD5Context context;
+		context.Add(input);
+		context.Finish(digest);
+		return *reinterpret_cast<hugeint_t *>(digest);
+	}
+};
+
+template <bool lower>
+struct MD5Number64Operator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input) {
+		data_t digest[MD5Context::MD5_HASH_LENGTH_BINARY];
+
+		MD5Context context;
+		context.Add(input);
+		context.Finish(digest);
+		return *reinterpret_cast<uint64_t *>(&digest[lower ? 8 : 0]);
+	}
+};
+
 static void MD5Function(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 
 	UnaryExecutor::ExecuteString<string_t, string_t, MD5Operator>(input, result, args.size());
 }
 
+static void MD5NumberFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+
+	UnaryExecutor::Execute<string_t, hugeint_t, MD5Number128Operator>(input, result, args.size());
+}
+
+static void MD5NumberUpperFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+
+	UnaryExecutor::Execute<string_t, uint64_t, MD5Number64Operator<false>>(input, result, args.size());
+}
+
+static void MD5NumberLowerFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+
+	UnaryExecutor::Execute<string_t, uint64_t, MD5Number64Operator<true>>(input, result, args.size());
+}
+
 void MD5Fun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("md5",                  // name of the function
 	                               {LogicalType::VARCHAR}, // argument list
 	                               LogicalType::VARCHAR,   // return type
 	                               MD5Function));          // pointer to function implementation
+
+	set.AddFunction(ScalarFunction("md5_number",           // name of the function
+	                               {LogicalType::VARCHAR}, // argument list
+	                               LogicalType::HUGEINT,   // return type
+	                               MD5NumberFunction));    // pointer to function implementation
+
+	set.AddFunction(ScalarFunction("md5_number_upper",       // name of the function
+	                               {LogicalType::VARCHAR},   // argument list
+	                               LogicalType::UBIGINT,     // return type
+	                               MD5NumberUpperFunction)); // pointer to function implementation
+
+	set.AddFunction(ScalarFunction("md5_number_lower",       // name of the function
+	                               {LogicalType::VARCHAR},   // argument list
+	                               LogicalType::UBIGINT,     // return type
+	                               MD5NumberLowerFunction)); // pointer to function implementation
 }
 
 } // namespace duckdb
@@ -128146,12 +128207,30 @@ bool Pipeline::GetProgressInternal(ClientContext &context, PhysicalOperator *op,
 			current_percentage = get.function.table_scan_progress(context, get.bind_data.get());
 			return true;
 		}
-		//! If the table_scan_progress is not implemented it means we don't support this function yet in the progress
-		//! bar
+		// If the table_scan_progress is not implemented it means we don't support this function yet in the progress
+		// bar
 		return false;
 	}
-	default:
-		return false;
+		// If it is not a table scan we go down on all children until we reach the leaf operators
+	default: {
+		vector<idx_t> progress;
+		vector<idx_t> cardinality;
+		double total_cardinality = 0;
+		current_percentage = 0;
+		for (auto &op_child : op->children) {
+			double child_percentage = 0;
+			if (!GetProgressInternal(context, op_child.get(), child_percentage)) {
+				return false;
+			}
+			progress.push_back(child_percentage);
+			cardinality.push_back(op_child->estimated_cardinality);
+			total_cardinality += op_child->estimated_cardinality;
+		}
+		for (size_t i = 0; i < progress.size(); i++) {
+			current_percentage += progress[i] * cardinality[i] / total_cardinality;
+		}
+		return true;
+	}
 	}
 }
 // LCOV_EXCL_STOP