Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Bundle jemalloc with JDBC Driver #131

Open
wants to merge 2 commits into
base: main
Choose a base branch
from
Open

Bundle jemalloc with JDBC Driver #131

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
ee54451
bundle-jemalloc: Bundle Jemalloc with JDBC driver
brianwyka Jan 19, 2025
9429beb
bundle-jemalloc: Update formatting
brianwyka Jan 19, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
The table of contents is too big for display.
Diff view
Diff view
  •  
  •  
  •  
2 changes: 1 addition & 1 deletion CMakeLists.txt
View file
Open in desktop

Large diffs are not rendered by default.

8 changes: 1 addition & 7 deletions src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -276,7 +276,7 @@ AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const Logical
return fun;
}

AggregateFunction GetMedianAbsoluteDeviationAggregateFunctionInternal(const LogicalType &type) {
AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType &type) {
switch (type.id()) {
case LogicalTypeId::FLOAT:
return GetTypedMedianAbsoluteDeviationAggregateFunction<float, float, float>(type, type);
Expand Down Expand Up @@ -314,12 +314,6 @@ AggregateFunction GetMedianAbsoluteDeviationAggregateFunctionInternal(const Logi
}
}

AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType &type) {
auto result = GetMedianAbsoluteDeviationAggregateFunctionInternal(type);
result.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR;
return result;
}

unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &context, AggregateFunction &function,
vector<unique_ptr<Expression>> &arguments) {
function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type);
Expand Down
11 changes: 2 additions & 9 deletions src/duckdb/extension/core_functions/scalar/array/array_functions.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -210,13 +210,9 @@ template <class OP>
static void AddArrayFoldFunction(ScalarFunctionSet &set, const LogicalType &type) {
const auto array = LogicalType::ARRAY(type, optional_idx());
if (type.id() == LogicalTypeId::FLOAT) {
ScalarFunction function({array, array}, type, ArrayGenericFold<float, OP>, ArrayGenericBinaryBind);
BaseScalarFunction::SetReturnsError(function);
set.AddFunction(function);
set.AddFunction(ScalarFunction({array, array}, type, ArrayGenericFold<float, OP>, ArrayGenericBinaryBind));
} else if (type.id() == LogicalTypeId::DOUBLE) {
ScalarFunction function({array, array}, type, ArrayGenericFold<double, OP>, ArrayGenericBinaryBind);
BaseScalarFunction::SetReturnsError(function);
set.AddFunction(function);
set.AddFunction(ScalarFunction({array, array}, type, ArrayGenericFold<double, OP>, ArrayGenericBinaryBind));
} else {
throw NotImplementedException("Array function not implemented for type %s", type.ToString());
}
Expand Down Expand Up @@ -271,9 +267,6 @@ ScalarFunctionSet ArrayCrossProductFun::GetFunctions() {
ScalarFunction({float_array, float_array}, float_array, ArrayFixedCombine<float, CrossProductOp, 3>));
set.AddFunction(
ScalarFunction({double_array, double_array}, double_array, ArrayFixedCombine<double, CrossProductOp, 3>));
for (auto &func : set.functions) {
BaseScalarFunction::SetReturnsError(func);
}
return set;
}

Expand Down
15 changes: 4 additions & 11 deletions src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -46,9 +46,6 @@ ScalarFunctionSet BitStringFun::GetFunctions() {
ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction<true>));
bitstring.AddFunction(
ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction<false>));
for (auto &func : bitstring.functions) {
BaseScalarFunction::SetReturnsError(func);
}
return bitstring;
}

Expand All @@ -67,10 +64,8 @@ struct GetBitOperator {
};

ScalarFunction GetBitFun::GetFunction() {
ScalarFunction func({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>);
BaseScalarFunction::SetReturnsError(func);
return func;
return ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>);
}

//===--------------------------------------------------------------------===//
Expand All @@ -95,10 +90,8 @@ static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &res
}

ScalarFunction SetBitFun::GetFunction() {
ScalarFunction function({LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER}, LogicalType::BIT,
SetBitOperation);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER}, LogicalType::BIT,
SetBitOperation);
}

//===--------------------------------------------------------------------===//
Expand Down
4 changes: 1 addition & 3 deletions src/duckdb/extension/core_functions/scalar/blob/base64.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -39,9 +39,7 @@ ScalarFunction ToBase64Fun::GetFunction() {
}

ScalarFunction FromBase64Fun::GetFunction() {
ScalarFunction function({LogicalType::VARCHAR}, LogicalType::BLOB, Base64DecodeFunction);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, Base64DecodeFunction);
}

} // namespace duckdb
4 changes: 1 addition & 3 deletions src/duckdb/extension/core_functions/scalar/blob/encode.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,9 +34,7 @@ ScalarFunction EncodeFun::GetFunction() {
}

ScalarFunction DecodeFun::GetFunction() {
ScalarFunction function({LogicalType::BLOB}, LogicalType::VARCHAR, DecodeFunction);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, DecodeFunction);
}

} // namespace duckdb
24 changes: 4 additions & 20 deletions src/duckdb/extension/core_functions/scalar/date/date_part.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1705,9 +1705,6 @@ ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar
operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr,
nullptr, ts_stats, DATE_CACHE));
operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
for (auto &func : operator_set.functions) {
BaseScalarFunction::SetReturnsError(func);
}
return operator_set;
}

Expand Down Expand Up @@ -2022,11 +2019,7 @@ ScalarFunctionSet QuarterFun::GetFunctions() {
}

ScalarFunctionSet DayOfWeekFun::GetFunctions() {
auto set = GetDatePartFunction<DatePart::DayOfWeekOperator>();
for (auto &func : set.functions) {
BaseScalarFunction::SetReturnsError(func);
}
return set;
return GetDatePartFunction<DatePart::DayOfWeekOperator>();
}

ScalarFunctionSet ISODayOfWeekFun::GetFunctions() {
Expand All @@ -2053,14 +2046,9 @@ ScalarFunctionSet TimezoneFun::GetFunctions() {
auto operator_set = GetDatePartFunction<DatePart::TimezoneOperator>();

// PG also defines timezone(INTERVAL, TIME_TZ) => TIME_TZ
ScalarFunction function({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
DatePart::TimezoneOperator::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t>);

operator_set.AddFunction(function);

for (auto &func : operator_set.functions) {
BaseScalarFunction::SetReturnsError(func);
}
operator_set.AddFunction(
ScalarFunction({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
DatePart::TimezoneOperator::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t>));

return operator_set;
}
Expand Down Expand Up @@ -2253,10 +2241,6 @@ ScalarFunctionSet DatePartFun::GetFunctions() {
date_part.AddFunction(StructDatePart::GetFunction<interval_t>(LogicalType::INTERVAL));
date_part.AddFunction(StructDatePart::GetFunction<dtime_tz_t>(LogicalType::TIME_TZ));

for (auto &func : date_part.functions) {
BaseScalarFunction::SetReturnsError(func);
}

return date_part;
}

Expand Down
3 changes: 0 additions & 3 deletions src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -728,9 +728,6 @@ ScalarFunctionSet DateTruncFun::GetFunctions() {
DateTruncFunction<date_t, timestamp_t>, DateTruncBind));
date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
DateTruncFunction<interval_t, interval_t>));
for (auto &func : date_trunc.functions) {
BaseScalarFunction::SetReturnsError(func);
}
return date_trunc;
}

Expand Down
2 changes: 1 addition & 1 deletion src/duckdb/extension/core_functions/scalar/date/epoch.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,7 @@ struct EpochSecOperator {
static RESULT_TYPE Operation(INPUT_TYPE sec) {
int64_t result;
if (!TryCast::Operation(sec * Interval::MICROS_PER_SEC, result)) {
throw ConversionException("Epoch seconds out of range for TIMESTAMP WITH TIME ZONE");
throw ConversionException("Could not convert epoch seconds to TIMESTAMP WITH TIME ZONE");
}
return timestamp_t(result);
}
Expand Down
17 changes: 2 additions & 15 deletions src/duckdb/extension/core_functions/scalar/date/make_date.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -103,10 +103,6 @@ struct MakeTimestampOperator {

template <typename T, typename RESULT_TYPE>
static RESULT_TYPE Operation(T value) {
const auto result = RESULT_TYPE(value);
if (!Timestamp::IsFinite(result)) {
throw ConversionException("Timestamp microseconds out of range: %ld", value);
}
return RESULT_TYPE(value);
}
};
Expand Down Expand Up @@ -144,17 +140,12 @@ ScalarFunctionSet MakeDateFun::GetFunctions() {
{"year", LogicalType::BIGINT}, {"month", LogicalType::BIGINT}, {"day", LogicalType::BIGINT}};
make_date.AddFunction(
ScalarFunction({LogicalType::STRUCT(make_date_children)}, LogicalType::DATE, ExecuteStructMakeDate<int64_t>));
for (auto &func : make_date.functions) {
BaseScalarFunction::SetReturnsError(func);
}
return make_date;
}

ScalarFunction MakeTimeFun::GetFunction() {
ScalarFunction function({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME,
ExecuteMakeTime<int64_t>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME,
ExecuteMakeTime<int64_t>);
}

ScalarFunctionSet MakeTimestampFun::GetFunctions() {
Expand All @@ -164,10 +155,6 @@ ScalarFunctionSet MakeTimestampFun::GetFunctions() {
LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
operator_set.AddFunction(
ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));

for (auto &func : operator_set.functions) {
BaseScalarFunction::SetReturnsError(func);
}
return operator_set;
}

Expand Down
3 changes: 0 additions & 3 deletions src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -364,9 +364,6 @@ ScalarFunctionSet TimeBucketFun::GetFunctions() {
LogicalType::DATE, TimeBucketOriginFunction<date_t>));
time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
LogicalType::TIMESTAMP, TimeBucketOriginFunction<timestamp_t>));
for (auto &func : time_bucket.functions) {
BaseScalarFunction::SetReturnsError(func);
}
return time_bucket;
}

Expand Down
78 changes: 26 additions & 52 deletions src/duckdb/extension/core_functions/scalar/date/to_interval.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -165,94 +165,68 @@ struct ToMicroSecondsOperator {
};

ScalarFunction ToMillenniaFun::GetFunction() {
ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToMillenniaOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToMillenniaOperator>);
}

ScalarFunction ToCenturiesFun::GetFunction() {
ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToCenturiesOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToCenturiesOperator>);
}

ScalarFunction ToDecadesFun::GetFunction() {
ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToDecadesOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToDecadesOperator>);
}

ScalarFunction ToYearsFun::GetFunction() {
ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
}

ScalarFunction ToQuartersFun::GetFunction() {
ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToQuartersOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToQuartersOperator>);
}

ScalarFunction ToMonthsFun::GetFunction() {
ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);
}

ScalarFunction ToWeeksFun::GetFunction() {
ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToWeeksOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToWeeksOperator>);
}

ScalarFunction ToDaysFun::GetFunction() {
ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>);
}

ScalarFunction ToHoursFun::GetFunction() {
ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>);
}

ScalarFunction ToMinutesFun::GetFunction() {
ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>);
}

ScalarFunction ToSecondsFun::GetFunction() {
ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<double, interval_t, ToSecondsOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::DOUBLE}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<double, interval_t, ToSecondsOperator>);
}

ScalarFunction ToMillisecondsFun::GetFunction() {
ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<double, interval_t, ToMilliSecondsOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::DOUBLE}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<double, interval_t, ToMilliSecondsOperator>);
}

ScalarFunction ToMicrosecondsFun::GetFunction() {
ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>);
BaseScalarFunction::SetReturnsError(function);
return function;
return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>);
}

} // namespace duckdb
1 change: 0 additions & 1 deletion src/duckdb/extension/core_functions/scalar/generic/binning.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -500,7 +500,6 @@ ScalarFunctionSet EquiWidthBinsFun::GetFunctions() {
for (auto &function : functions.functions) {
function.serialize = EquiWidthBinSerialize;
function.deserialize = EquiWidthBinDeserialize;
BaseScalarFunction::SetReturnsError(function);
}
return functions;
}
Expand Down
2 changes: 1 addition & 1 deletion src/duckdb/extension/core_functions/scalar/list/array_slice.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -449,7 +449,7 @@ ScalarFunctionSet ListSliceFun::GetFunctions() {
ScalarFunction fun({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ArraySliceFunction,
ArraySliceBind);
fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
BaseScalarFunction::SetReturnsError(fun);

ScalarFunctionSet set;
set.AddFunction(fun);
fun.arguments.push_back(LogicalType::BIGINT);
Expand Down
2 changes: 0 additions & 2 deletions src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -468,7 +468,6 @@ static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, Scala
// found a matching function, bind it as an aggregate
auto best_function = func.functions.GetFunctionByOffset(best_function_idx.GetIndex());
if (IS_AGGR) {
bound_function.errors = best_function.errors;
return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, child_type, best_function, arguments);
}

Expand Down Expand Up @@ -513,7 +512,6 @@ static unique_ptr<FunctionData> ListUniqueBind(ClientContext &context, ScalarFun
ScalarFunction ListAggregateFun::GetFunction() {
auto result = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY,
ListAggregateFunction, ListAggregateBind);
BaseScalarFunction::SetReturnsError(result);
result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
result.varargs = LogicalType::ANY;
result.serialize = ListAggregatesBindData::SerializeFunction;
Expand Down
Loading
Loading