duckdb 0.7.2-dev904.0 → 0.7.2-dev982.0

package/package.json

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

package/src/duckdb/src/common/enums/logical_operator_type.cpp

@@ -20,6 +20,8 @@ string LogicalOperatorToString(LogicalOperatorType type) {
 		return "EXPRESSION_GET";
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 		return "ANY_JOIN";
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+		return "ASOF_JOIN";
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		return "COMPARISON_JOIN";
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:

package/src/duckdb/src/common/serializer/enum_serializer.cpp

@@ -236,6 +236,8 @@ JoinRefType EnumSerializer::StringToEnum(const char *value) {
 		return JoinRefType::CROSS;
 	} else if (StringUtil::Equals(value, "POSITIONAL")) {
 		return JoinRefType::POSITIONAL;
+	} else if (StringUtil::Equals(value, "ASOF")) {
+		return JoinRefType::ASOF;
 	} else {
 		throw NotImplementedException("EnumSerializer::StringToEnum not implemented for enum value");
 	}
@@ -252,6 +254,8 @@ const char *EnumSerializer::EnumToString(JoinRefType value) {
 		return "CROSS";
 	case JoinRefType::POSITIONAL:
 		return "POSITIONAL";
+	case JoinRefType::ASOF:
+		return "ASOF";
 	default:
 		throw NotImplementedException("ToString not implemented for enum value");
 	}

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

@@ -330,6 +330,52 @@ Value Value::MaximumValue(const LogicalType &type) {
 	}
 }
 
+Value Value::Infinity(const LogicalType &type) {
+	switch (type.id()) {
+	case LogicalTypeId::DATE:
+		return Value::DATE(date_t::infinity());
+	case LogicalTypeId::TIMESTAMP:
+		return Value::TIMESTAMP(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_MS:
+		return Value::TIMESTAMPMS(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_NS:
+		return Value::TIMESTAMPNS(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return Value::TIMESTAMPSEC(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_t::infinity());
+	case LogicalTypeId::FLOAT:
+		return Value::FLOAT(std::numeric_limits<float>::infinity());
+	case LogicalTypeId::DOUBLE:
+		return Value::DOUBLE(std::numeric_limits<double>::infinity());
+	default:
+		throw InvalidTypeException(type, "Infinity requires numeric type");
+	}
+}
+
+Value Value::NegativeInfinity(const LogicalType &type) {
+	switch (type.id()) {
+	case LogicalTypeId::DATE:
+		return Value::DATE(date_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP:
+		return Value::TIMESTAMP(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_MS:
+		return Value::TIMESTAMPMS(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_NS:
+		return Value::TIMESTAMPNS(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return Value::TIMESTAMPSEC(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_t::ninfinity());
+	case LogicalTypeId::FLOAT:
+		return Value::FLOAT(-std::numeric_limits<float>::infinity());
+	case LogicalTypeId::DOUBLE:
+		return Value::DOUBLE(-std::numeric_limits<double>::infinity());
+	default:
+		throw InvalidTypeException(type, "NegativeInfinity requires numeric type");
+	}
+}
+
 Value Value::BOOLEAN(int8_t value) {
 	Value result(LogicalType::BOOLEAN);
 	result.value_.boolean = bool(value);

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -18,7 +18,10 @@ ColumnBindingResolver::ColumnBindingResolver() {
 }
 
 void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN || op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+	switch (op.type) {
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
+	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
 		// special case: comparison join
 		auto &comp_join = (LogicalComparisonJoin &)op;
 		// first get the bindings of the LHS and resolve the LHS expressions
@@ -41,7 +44,8 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		// finally update the bindings with the result bindings of the join
 		bindings = op.GetColumnBindings();
 		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
+	}
+	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
 		// ANY join, this join is different because we evaluate the expression on the bindings of BOTH join sides at
 		// once i.e. we set the bindings first to the bindings of the entire join, and then resolve the expressions of
 		// this operator
@@ -54,19 +58,22 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		}
 		VisitOperatorExpressions(op);
 		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_CREATE_INDEX) {
+	}
+	case LogicalOperatorType::LOGICAL_CREATE_INDEX: {
 		// CREATE INDEX statement, add the columns of the table with table index 0 to the binding set
 		// afterwards bind the expressions of the CREATE INDEX statement
 		auto &create_index = (LogicalCreateIndex &)op;
 		bindings = LogicalOperator::GenerateColumnBindings(0, create_index.table.GetColumns().LogicalColumnCount());
 		VisitOperatorExpressions(op);
 		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_GET) {
+	}
+	case LogicalOperatorType::LOGICAL_GET: {
 		//! We first need to update the current set of bindings and then visit operator expressions
 		bindings = op.GetColumnBindings();
 		VisitOperatorExpressions(op);
 		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_INSERT) {
+	}
+	case LogicalOperatorType::LOGICAL_INSERT: {
 		//! We want to execute the normal path, but also add a dummy 'excluded' binding if there is a
 		// ON CONFLICT DO UPDATE clause
 		auto &insert_op = (LogicalInsert &)op;
@@ -89,6 +96,9 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 			return;
 		}
 	}
+	default:
+		break;
+	}
 	// general case
 	// first visit the children of this operator
 	VisitOperatorChildren(op);

package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp

@@ -130,8 +130,10 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
 	}
 
 	// now perform the actual join
-	// we perform a cross product, then execute the expression directly on the cross product' result
+	// we perform a cross product, then execute the expression directly on the cross product result
 	idx_t result_count = 0;
+	bool found_match[STANDARD_VECTOR_SIZE] = {false};
+
 	do {
 		auto result = state.cross_product.Execute(input, *intermediate_chunk);
 		if (result == OperatorResultType::NEED_MORE_INPUT) {
@@ -142,39 +144,58 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
 				state.left_outer.ConstructLeftJoinResult(input, *intermediate_chunk);
 				state.left_outer.Reset();
 			}
+
+			if (join_type == JoinType::SEMI) {
+				PhysicalJoin::ConstructSemiJoinResult(input, chunk, found_match);
+			}
+			if (join_type == JoinType::ANTI) {
+				PhysicalJoin::ConstructAntiJoinResult(input, chunk, found_match);
+			}
+
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
 		// now perform the computation
 		result_count = state.executor.SelectExpression(*intermediate_chunk, state.match_sel);
+
+		// handle anti and semi joins with different logic
 		if (result_count > 0) {
 			// found a match!
-			// check if the cross product is scanning the LHS or the RHS in its entirety
-			if (!state.cross_product.ScanLHS()) {
-				// set the match flags in the LHS
-				state.left_outer.SetMatches(state.match_sel, result_count);
-				// set the match flag in the RHS
-				gstate.right_outer.SetMatch(state.cross_product.ScanPosition() + state.cross_product.PositionInChunk());
+			// handle anti semi join conditions first
+			if (join_type == JoinType::ANTI || join_type == JoinType::SEMI) {
+				if (state.cross_product.ScanLHS()) {
+					found_match[state.cross_product.PositionInChunk()] = true;
+				} else {
+					for (idx_t i = 0; i < result_count; i++) {
+						found_match[state.match_sel.get_index(i)] = true;
+					}
+				}
+				intermediate_chunk->Reset();
+				// trick the loop to continue as semi and anti joins will never produce more output than
+				// the LHS cardinality
+				result_count = 0;
 			} else {
-				// set the match flag in the LHS
-				state.left_outer.SetMatch(state.cross_product.PositionInChunk());
-				// set the match flags in the RHS
-				gstate.right_outer.SetMatches(state.match_sel, result_count, state.cross_product.ScanPosition());
+				// check if the cross product is scanning the LHS or the RHS in its entirety
+				if (!state.cross_product.ScanLHS()) {
+					// set the match flags in the LHS
+					state.left_outer.SetMatches(state.match_sel, result_count);
+					// set the match flag in the RHS
+					gstate.right_outer.SetMatch(state.cross_product.ScanPosition() +
+					                            state.cross_product.PositionInChunk());
+				} else {
+					// set the match flag in the LHS
+					state.left_outer.SetMatch(state.cross_product.PositionInChunk());
+					// set the match flags in the RHS
+					gstate.right_outer.SetMatches(state.match_sel, result_count, state.cross_product.ScanPosition());
+				}
+				intermediate_chunk->Slice(state.match_sel, result_count);
 			}
-			intermediate_chunk->Slice(state.match_sel, result_count);
 		} else {
 			// no result: reset the chunk
 			intermediate_chunk->Reset();
 		}
 	} while (result_count == 0);
 
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		for (idx_t col_idx = 0; col_idx < chunk.ColumnCount(); col_idx++) {
-			chunk.data[col_idx].Reference(intermediate_chunk->data[col_idx]);
-		}
-		chunk.SetCardinality(*intermediate_chunk);
-	}
-
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 

package/src/duckdb/src/execution/operator/join/physical_range_join.cpp

@@ -334,7 +334,9 @@ idx_t PhysicalRangeJoin::SelectJoinTail(const ExpressionType &condition, Vector
 	case ExpressionType::COMPARE_DISTINCT_FROM:
 		return VectorOperations::DistinctFrom(left, right, sel, count, true_sel, nullptr);
 	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+		return VectorOperations::NotDistinctFrom(left, right, sel, count, true_sel, nullptr);
 	case ExpressionType::COMPARE_EQUAL:
+		return VectorOperations::Equals(left, right, sel, count, true_sel, nullptr);
 	default:
 		throw InternalException("Unsupported comparison type for PhysicalRangeJoin");
 	}

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

@@ -498,12 +498,12 @@ bool BaseCSVReader::Flush(DataChunk &insert_chunk, bool try_add_line) {
 			}
 
 			// figure out the exact line number
+			UnifiedVectorFormat inserted_column_data;
+			insert_chunk.data[col_idx].ToUnifiedFormat(parse_chunk.size(), inserted_column_data);
 			idx_t row_idx;
 			for (row_idx = 0; row_idx < parse_chunk.size(); row_idx++) {
-				auto &inserted_column = insert_chunk.data[col_idx];
 				auto &parsed_column = parse_chunk.data[col_idx];
-
-				if (FlatVector::IsNull(inserted_column, row_idx) && !FlatVector::IsNull(parsed_column, row_idx)) {
+				if (!inserted_column_data.validity.RowIsValid(row_idx) && !FlatVector::IsNull(parsed_column, row_idx)) {
 					break;
 				}
 			}

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

@@ -870,16 +870,7 @@ vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &reque
 	// #######
 	// ### type detection (initial)
 	// #######
-	// type candidates, ordered by descending specificity (~ from high to low)
-	vector<LogicalType> type_candidates = {
-	    LogicalType::VARCHAR,
-	    LogicalType::TIMESTAMP,
-	    LogicalType::DATE,
-	    LogicalType::TIME,
-	    LogicalType::DOUBLE,
-	    /* LogicalType::FLOAT,*/ LogicalType::BIGINT,
-	    /*LogicalType::INTEGER,*/ /*LogicalType::SMALLINT, LogicalType::TINYINT,*/ LogicalType::BOOLEAN,
-	    LogicalType::SQLNULL};
+
 	// format template candidates, ordered by descending specificity (~ from high to low)
 	std::map<LogicalTypeId, vector<const char *>> format_template_candidates = {
 	    {LogicalTypeId::DATE, {"%m-%d-%Y", "%m-%d-%y", "%d-%m-%Y", "%d-%m-%y", "%Y-%m-%d", "%y-%m-%d"}},
@@ -890,8 +881,8 @@ vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &reque
 	vector<vector<LogicalType>> best_sql_types_candidates;
 	map<LogicalTypeId, vector<string>> best_format_candidates;
 	DataChunk best_header_row;
-	DetectCandidateTypes(type_candidates, format_template_candidates, info_candidates, original_options, best_num_cols,
-	                     best_sql_types_candidates, best_format_candidates, best_header_row);
+	DetectCandidateTypes(options.auto_type_candidates, format_template_candidates, info_candidates, original_options,
+	                     best_num_cols, best_sql_types_candidates, best_format_candidates, best_header_row);
 
 	if (best_format_candidates.empty() || best_header_row.size() == 0) {
 		throw InvalidInputException(
@@ -939,7 +930,8 @@ vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &reque
 	// #######
 	// ### type detection (refining)
 	// #######
-	return RefineTypeDetection(type_candidates, requested_types, best_sql_types_candidates, best_format_candidates);
+	return RefineTypeDetection(options.auto_type_candidates, requested_types, best_sql_types_candidates,
+	                           best_format_candidates);
 }
 
 bool BufferedCSVReader::TryParseComplexCSV(DataChunk &insert_chunk, string &error_message) {

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

@@ -1,6 +1,7 @@
 #include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 
 namespace duckdb {
 
@@ -35,6 +36,39 @@ unique_ptr<OperatorState> PhysicalProjection::GetOperatorState(ExecutionContext
 	return make_unique<ProjectionState>(context, select_list);
 }
 
+unique_ptr<PhysicalOperator>
+PhysicalProjection::CreateJoinProjection(vector<LogicalType> proj_types, const vector<LogicalType> &lhs_types,
+                                         const vector<LogicalType> &rhs_types, const vector<idx_t> &left_projection_map,
+                                         const vector<idx_t> &right_projection_map, const idx_t estimated_cardinality) {
+
+	vector<unique_ptr<Expression>> proj_selects;
+	proj_selects.reserve(proj_types.size());
+
+	if (left_projection_map.empty()) {
+		for (storage_t i = 0; i < lhs_types.size(); ++i) {
+			proj_selects.emplace_back(make_unique<BoundReferenceExpression>(lhs_types[i], i));
+		}
+	} else {
+		for (auto i : left_projection_map) {
+			proj_selects.emplace_back(make_unique<BoundReferenceExpression>(lhs_types[i], i));
+		}
+	}
+	const auto left_cols = lhs_types.size();
+
+	if (right_projection_map.empty()) {
+		for (storage_t i = 0; i < rhs_types.size(); ++i) {
+			proj_selects.emplace_back(make_unique<BoundReferenceExpression>(rhs_types[i], left_cols + i));
+		}
+
+	} else {
+		for (auto i : right_projection_map) {
+			proj_selects.emplace_back(make_unique<BoundReferenceExpression>(rhs_types[i], left_cols + i));
+		}
+	}
+
+	return make_unique<PhysicalProjection>(std::move(proj_types), std::move(proj_selects), estimated_cardinality);
+}
+
 string PhysicalProjection::ParamsToString() const {
 	string extra_info;
 	for (auto &expr : select_list) {

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

@@ -0,0 +1,97 @@
+#include "duckdb/execution/operator/aggregate/physical_window.hpp"
+#include "duckdb/execution/operator/join/physical_iejoin.hpp"
+#include "duckdb/execution/operator/projection/physical_projection.hpp"
+#include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/expression/bound_window_expression.hpp"
+#include "duckdb/planner/operator/logical_asof_join.hpp"
+
+namespace duckdb {
+
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &op) {
+	// now visit the children
+	D_ASSERT(op.children.size() == 2);
+	idx_t lhs_cardinality = op.children[0]->EstimateCardinality(context);
+	idx_t rhs_cardinality = op.children[1]->EstimateCardinality(context);
+	auto left = CreatePlan(*op.children[0]);
+	auto right = CreatePlan(*op.children[1]);
+	D_ASSERT(left && right);
+
+	//	Validate
+	vector<idx_t> equi_indexes;
+	auto asof_idx = op.conditions.size();
+	for (size_t c = 0; c < op.conditions.size(); ++c) {
+		auto &cond = op.conditions[c];
+		switch (cond.comparison) {
+		case ExpressionType::COMPARE_EQUAL:
+		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+			equi_indexes.emplace_back(c);
+			break;
+		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+			D_ASSERT(asof_idx == op.conditions.size());
+			asof_idx = c;
+			break;
+		default:
+			throw InternalException("Invalid ASOF JOIN comparison");
+		}
+	}
+	D_ASSERT(asof_idx < op.conditions.size());
+
+	//	Temporary implementation: IEJoin of Window
+	//	LEAD(asof_column, 1, infinity) OVER (PARTITION BY equi_column... ORDER BY asof_column) AS asof_temp
+	auto &asof_comp = op.conditions[asof_idx];
+	auto &asof_column = asof_comp.right;
+	auto asof_type = asof_column->return_type;
+	auto asof_temp = make_unique<BoundWindowExpression>(ExpressionType::WINDOW_LEAD, asof_type, nullptr, nullptr);
+	asof_temp->children.emplace_back(asof_column->Copy());
+	asof_temp->offset_expr = make_unique<BoundConstantExpression>(Value::BIGINT(1));
+	asof_temp->default_expr = make_unique<BoundConstantExpression>(Value::Infinity(asof_type));
+	for (auto equi_idx : equi_indexes) {
+		asof_temp->partitions.emplace_back(op.conditions[equi_idx].right->Copy());
+	}
+	asof_temp->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, asof_column->Copy());
+	asof_temp->start = WindowBoundary::UNBOUNDED_PRECEDING;
+	asof_temp->end = WindowBoundary::CURRENT_ROW_ROWS;
+
+	vector<unique_ptr<Expression>> window_select;
+	window_select.emplace_back(std::move(asof_temp));
+
+	auto window_types = right->types;
+	window_types.emplace_back(asof_type);
+
+	auto window = make_unique<PhysicalWindow>(window_types, std::move(window_select), rhs_cardinality);
+	window->children.emplace_back(std::move(right));
+
+	// IEJoin(left, window, conditions || asof_column < asof_temp)
+	JoinCondition asof_upper;
+	asof_upper.left = asof_comp.left->Copy();
+	asof_upper.right = make_unique<BoundReferenceExpression>(asof_type, window_types.size() - 1);
+	asof_upper.comparison = ExpressionType::COMPARE_LESSTHAN;
+
+	// We have an equality condition, so we may have to deal with projection maps.
+	// IEJoin does not (currently) support them, so we have to do it manually
+	auto proj_types = op.types;
+	op.types.clear();
+
+	auto lhs_types = op.children[0]->types;
+	op.types = lhs_types;
+
+	auto rhs_types = op.children[1]->types;
+	op.types.insert(op.types.end(), rhs_types.begin(), rhs_types.end());
+
+	op.types.emplace_back(asof_type);
+	op.conditions.emplace_back(std::move(asof_upper));
+	auto iejoin = make_unique<PhysicalIEJoin>(op, std::move(left), std::move(window), std::move(op.conditions),
+	                                          op.join_type, op.estimated_cardinality);
+
+	//	Project away asof_temp and anything from the projection maps
+	auto proj = PhysicalProjection::CreateJoinProjection(proj_types, lhs_types, rhs_types, op.left_projection_map,
+	                                                     op.right_projection_map, lhs_cardinality);
+	proj->children.push_back(std::move(iejoin));
+
+	return proj;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -115,6 +115,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 		plan = CreatePlan((LogicalDelimJoin &)op);
 		break;
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+		plan = CreatePlan((LogicalAsOfJoin &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		plan = CreatePlan((LogicalComparisonJoin &)op);
 		break;

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

@@ -2,6 +2,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/scalar/trigonometric_functions.hpp"
 #include "duckdb/common/operator/abs.hpp"
+#include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
@@ -1161,4 +1162,90 @@ void EvenFun::RegisterFunction(BuiltinFunctions &set) {
 	                               ScalarFunction::UnaryFunction<double, double, EvenOperator>));
 }
 
+//===--------------------------------------------------------------------===//
+// gcd
+//===--------------------------------------------------------------------===//
+
+// should be replaced with std::gcd in a newer C++ standard
+template <class TA>
+TA GreatestCommonDivisor(TA left, TA right) {
+	TA a = left;
+	TA b = right;
+
+	// This protects the following modulo operations from a corner case,
+	// where we would get a runtime error due to an integer overflow.
+	if ((left == NumericLimits<TA>::Minimum() && right == -1) ||
+	    (left == -1 && right == NumericLimits<TA>::Minimum())) {
+		return 1;
+	}
+
+	while (true) {
+		if (a == 0) {
+			return TryAbsOperator::Operation<TA, TA>(b);
+		}
+		b %= a;
+
+		if (b == 0) {
+			return TryAbsOperator::Operation<TA, TA>(a);
+		}
+		a %= b;
+	}
+}
+
+struct GreatestCommonDivisorOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return GreatestCommonDivisor(left, right);
+	}
+};
+
+void GreatestCommonDivisorFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("gcd");
+
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::BIGINT,
+	                   ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, GreatestCommonDivisorOperator>));
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT,
+	                   ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, GreatestCommonDivisorOperator>));
+
+	set.AddFunction(funcs);
+	funcs.name = "greatest_common_divisor";
+	set.AddFunction(funcs);
+}
+
+//===--------------------------------------------------------------------===//
+// lcm
+//===--------------------------------------------------------------------===//
+
+// should be replaced with std::lcm in a newer C++ standard
+struct LeastCommonMultipleOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		if (left == 0 || right == 0) {
+			return 0;
+		}
+		TR result;
+		if (!TryMultiplyOperator::Operation<TA, TB, TR>(left, right / GreatestCommonDivisor(left, right), result)) {
+			throw OutOfRangeException("lcm value is out of range");
+		}
+		return TryAbsOperator::Operation<TR, TR>(result);
+	}
+};
+
+void LeastCommonMultipleFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("lcm");
+
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::BIGINT,
+	                   ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, LeastCommonMultipleOperator>));
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT,
+	                   ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, LeastCommonMultipleOperator>));
+
+	set.AddFunction(funcs);
+	funcs.name = "least_common_multiple";
+	set.AddFunction(funcs);
+}
+
 } // namespace duckdb

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

@@ -41,6 +41,9 @@ void BuiltinFunctions::RegisterMathFunctions() {
 	Register<SignBitFun>();
 	Register<IsInfiniteFun>();
 	Register<IsFiniteFun>();
+
+	Register<GreatestCommonDivisorFun>();
+	Register<LeastCommonMultipleFun>();
 }
 
 } // namespace duckdb