Datum
to_tsquery(PG_FUNCTION_ARGS)
{
text *in = PG_GETARG_TEXT_P(0);
Oid cfgId;
cfgId = getTSCurrentConfig(true);
PG_RETURN_DATUM(DirectFunctionCall2(to_tsquery_byid,
ObjectIdGetDatum(cfgId),
PointerGetDatum(in)));
}
Datum
similarity_op(PG_FUNCTION_ARGS)
{
float4 res = DatumGetFloat4(DirectFunctionCall2(
similarity,
PG_GETARG_DATUM(0),
PG_GETARG_DATUM(1)
));
PG_RETURN_BOOL(res >= trgm_limit);
}
Datum
gpupreagg_psum_x2_numeric(PG_FUNCTION_ARGS)
{
Assert(PG_NARGS() == 1);
if (PG_ARGISNULL(0))
PG_RETURN_NULL();
PG_RETURN_NUMERIC(DirectFunctionCall2(numeric_mul,
PG_GETARG_DATUM(0),
PG_GETARG_DATUM(0)));
}
static int
compareNumeric(Numeric a, Numeric b)
{
return DatumGetInt32(
DirectFunctionCall2(
numeric_cmp,
PointerGetDatum(a),
PointerGetDatum(b)
)
);
}
Datum
_int_different(PG_FUNCTION_ARGS)
{
PG_RETURN_BOOL(!DatumGetBool(
DirectFunctionCall2(
_int_same,
PointerGetDatum(PG_GETARG_POINTER(0)),
PointerGetDatum(PG_GETARG_POINTER(1))
)
));
}
Datum
tsq_mcontained(PG_FUNCTION_ARGS)
{
PG_RETURN_DATUM(
DirectFunctionCall2(
tsq_mcontains,
PG_GETARG_DATUM(1),
PG_GETARG_DATUM(0)
)
);
}
static int
tskey_cmp(const void *a, const void *b)
{
return DatumGetInt32(
DirectFunctionCall2(
timestamp_cmp,
TimestampGetDatumFast(((TSKEY *) (((RIX *) a)->r))->lower),
TimestampGetDatumFast(((TSKEY *) (((RIX *) b)->r))->lower)
)
);
}
/*
* Compute the difference in bytes between two WAL locations.
*/
Datum
pg_xlog_location_diff(PG_FUNCTION_ARGS)
{
Datum result;
result = DirectFunctionCall2(pg_lsn_mi,
PG_GETARG_DATUM(0),
PG_GETARG_DATUM(1));
PG_RETURN_NUMERIC(result);
}
static int
gbt_macadkey_cmp(const void *a, const void *b)
{
return DatumGetInt32(
DirectFunctionCall2(
macaddr_cmp,
PointerGetDatum(&((Nsrt *) a)->t[0]),
PointerGetDatum(&((Nsrt *) b)->t[0])
)
);
}
Datum
gbt_time_penalty(PG_FUNCTION_ARGS)
{
timeKEY *origentry = (timeKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
timeKEY *newentry = (timeKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *result = (float *) PG_GETARG_POINTER(2);
Interval *intr;
double res;
double res2;
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
P_TimeADTGetDatum(newentry->upper),
P_TimeADTGetDatum(origentry->upper)));
res = INTERVAL_TO_SEC(intr);
res = Max(res, 0);
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
P_TimeADTGetDatum(origentry->lower),
P_TimeADTGetDatum(newentry->lower)));
res2 = INTERVAL_TO_SEC(intr);
res2 = Max(res2, 0);
res += res2;
*result = 0.0;
if (res > 0)
{
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
P_TimeADTGetDatum(origentry->upper),
P_TimeADTGetDatum(origentry->lower)));
*result += FLT_MIN;
*result += (float) (res / (res + INTERVAL_TO_SEC(intr)));
*result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
}
PG_RETURN_POINTER(result);
}
static float8
gbt_time_dist(const void *a, const void *b)
{
const TimeADT *aa = (const TimeADT *) a;
const TimeADT *bb = (const TimeADT *) b;
Interval *i;
i = DatumGetIntervalP(DirectFunctionCall2(time_mi_time,
TimeADTGetDatumFast(*aa),
TimeADTGetDatumFast(*bb)));
return (float8) Abs(INTERVAL_TO_SEC(i));
}
/*
* The GiST Penalty method for boxes (also used for points)
*
* As in the R-tree paper, we use change in area as our penalty metric
*/
Datum
gist_box_penalty(PG_FUNCTION_ARGS)
{
GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
float *result = (float *) PG_GETARG_POINTER(2);
Datum ud;
ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key);
*result = (float) (size_box(ud) - size_box(origentry->key));
PG_RETURN_POINTER(result);
}
Datum
pgstrom_final_avg_int8_final(PG_FUNCTION_ARGS)
{
ArrayType *xarray = PG_GETARG_ARRAYTYPE_P(0);
int64 *x = (int64 *)ARR_DATA_PTR(xarray);
return DirectFunctionCall2(numeric_div,
DirectFunctionCall1(int8_numeric,
Int64GetDatum(x[0])),
DirectFunctionCall1(int8_numeric,
Int64GetDatum(x[1])));
}
/* plainto_tsquery(text, text) */
Datum
tsa_plainto_tsquery_name(PG_FUNCTION_ARGS)
{
text *cfgname = PG_GETARG_TEXT_P(0);
Datum arg1 = PG_GETARG_DATUM(1);
Oid config_oid;
config_oid = TextGetObjectId(regconfigin, cfgname);
return DirectFunctionCall2(plainto_tsquery_byid,
ObjectIdGetDatum(config_oid), arg1);
}
Datum
spheretrans_point_inverse(PG_FUNCTION_ARGS)
{
Datum sp = PG_GETARG_DATUM(0);
SEuler *se = (SEuler *) PG_GETARG_POINTER(1);
SEuler tmp;
Datum ret;
spheretrans_inverse(&tmp, se);
ret = DirectFunctionCall2(spheretrans_point,
sp, PointerGetDatum(&tmp));
PG_RETURN_DATUM(ret);
}
Interval *
abs_interval(Interval *a)
{
static Interval zero = {0, 0, 0};
if (DatumGetBool(DirectFunctionCall2(interval_lt,
IntervalPGetDatum(a),
IntervalPGetDatum(&zero))))
a = DatumGetIntervalP(DirectFunctionCall1(interval_um,
IntervalPGetDatum(a)));
return a;
}
/*
** Equality method
*/
Datum
gbox_same(PG_FUNCTION_ARGS)
{
BOX *b1 = (BOX *) PG_GETARG_POINTER(0);
BOX *b2 = (BOX *) PG_GETARG_POINTER(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
if (b1 && b2)
*result = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(b1), PointerGetDatum(b2)));
else
*result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
PG_RETURN_POINTER(result);
}
Datum
pt_in_widget(PG_FUNCTION_ARGS)
{
Point *point = PG_GETARG_POINT_P(0);
WIDGET *widget = (WIDGET *) PG_GETARG_POINTER(1);
float8 distance;
distance = DatumGetFloat8(DirectFunctionCall2(point_distance,
PointPGetDatum(point),
PointPGetDatum(&widget->center)));
PG_RETURN_BOOL(distance < widget->radius);
}
Datum
interpt_pp(PG_FUNCTION_ARGS)
{
PATH *p1 = PG_GETARG_PATH_P(0);
PATH *p2 = PG_GETARG_PATH_P(1);
int i,
j;
LSEG seg1,
seg2;
bool found; /* We've found the intersection */
found = false; /* Haven't found it yet */
for (i = 0; i < p1->npts - 1 && !found; i++)
{
regress_lseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
for (j = 0; j < p2->npts - 1 && !found; j++)
{
regress_lseg_construct(&seg2, &p2->p[j], &p2->p[j + 1]);
if (DatumGetBool(DirectFunctionCall2(lseg_intersect,
LsegPGetDatum(&seg1),
LsegPGetDatum(&seg2))))
found = true;
}
}
if (!found)
PG_RETURN_NULL();
/*
* Note: DirectFunctionCall2 will kick out an error if lseg_interpt()
* returns NULL, but that should be impossible since we know the two
* segments intersect.
*/
PG_RETURN_DATUM(DirectFunctionCall2(lseg_interpt,
LsegPGetDatum(&seg1),
LsegPGetDatum(&seg2)));
}
Datum
gbt_date_penalty(PG_FUNCTION_ARGS)
{
dateKEY *origentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
dateKEY *newentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *result = (float *) PG_GETARG_POINTER(2);
int32 diff,
res;
diff = DatumGetInt32(DirectFunctionCall2(
date_mi,
DateADTGetDatum(newentry->upper),
DateADTGetDatum(origentry->upper)));
res = Max(diff, 0);
diff = DatumGetInt32(DirectFunctionCall2(
date_mi,
DateADTGetDatum(origentry->lower),
DateADTGetDatum(newentry->lower)));
res += Max(diff, 0);
*result = 0.0;
if (res > 0)
{
diff = DatumGetInt32(DirectFunctionCall2(
date_mi,
DateADTGetDatum(origentry->upper),
DateADTGetDatum(origentry->lower)));
*result += FLT_MIN;
*result += (float) (res / ((double) (res + diff)));
*result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
}
PG_RETURN_POINTER(result);
}
/*
* pgstrom.psum_x2(numeric)
*/
Datum
pgstrom_partial_sum_x2_numeric(PG_FUNCTION_ARGS)
{
Datum value;
if (!PG_ARGISNULL(0))
value = PG_GETARG_DATUM(0); /* a valid numeric value */
else
value = DirectFunctionCall3(numeric_in,
CStringGetDatum("0"),
ObjectIdGetDatum(InvalidOid),
Int32GetDatum(-1));
return DirectFunctionCall2(numeric_mul, value, value);
}
static float
size_box(Datum box)
{
if (DatumGetPointer(box) != NULL)
{
float size;
DirectFunctionCall2(rt_box_size,
box, PointerGetDatum(&size));
return size;
}
else
return 0.0;
}
Datum
to_tsquery_name(PG_FUNCTION_ARGS)
{
text *name = PG_GETARG_TEXT_P(0);
Datum res;
SET_FUNCOID();
res = DirectFunctionCall2(to_tsquery,
Int32GetDatum(name2id_cfg(name)),
PG_GETARG_DATUM(1));
PG_FREE_IF_COPY(name, 0);
PG_RETURN_DATUM(res);
}
Datum
ipaddr_cmp(PG_FUNCTION_ARGS)
{
IP_P ipp1 = PG_GETARG_IP_P(0);
IP_P ipp2 = PG_GETARG_IP_P(1);
IP ip1;
IP ip2;
int af1 = ip_unpack(ipp1, &ip1);
int af2 = ip_unpack(ipp2, &ip2);
int32 retval;
if (af1 != af2)
{
retval = (af1 > af2) ? 1 : -1;
}
else
{
switch (af1)
{
case PGSQL_AF_INET:
retval = DatumGetInt32(DirectFunctionCall2(ip4_cmp, IP4GetDatum(ip1.ip4), IP4GetDatum(ip2.ip4)));
break;
case PGSQL_AF_INET6:
retval = DatumGetInt32(DirectFunctionCall2(ip6_cmp, IP6PGetDatum(&ip1.ip6), IP6PGetDatum(&ip2.ip6)));
break;
default:
ipaddr_internal_error();
}
}
PG_FREE_IF_COPY(ipp1,0);
PG_FREE_IF_COPY(ipp2,1);
PG_RETURN_INT32(retval);
}
static Jsonb *
jnumber_op(PGFunction f, Jsonb *l, Jsonb *r)
{
FunctionCallInfoData fcinfo;
JsonbValue *jv;
Datum n;
AssertArg(r != NULL);
if (!((l == NULL || JB_ROOT_IS_SCALAR(l)) && JB_ROOT_IS_SCALAR(r)))
ereport_op(f, l, r);
InitFunctionCallInfoData(fcinfo, NULL, 0, InvalidOid, NULL, NULL);
if (l != NULL)
{
jv = getIthJsonbValueFromContainer(&l->root, 0);
if (jv->type != jbvNumeric)
ereport_op(f, l, r);
fcinfo.arg[fcinfo.nargs] = NumericGetDatum(jv->val.numeric);
fcinfo.argnull[fcinfo.nargs] = false;
fcinfo.nargs++;
}
jv = getIthJsonbValueFromContainer(&r->root, 0);
if (jv->type != jbvNumeric)
ereport_op(f, l, r);
fcinfo.arg[fcinfo.nargs] = NumericGetDatum(jv->val.numeric);
fcinfo.argnull[fcinfo.nargs] = false;
fcinfo.nargs++;
n = (*f) (&fcinfo);
if (fcinfo.isnull)
elog(ERROR, "function %p returned NULL", (void *) f);
if (f == numeric_power || f == numeric_div)
{
int s;
s = DatumGetInt32(DirectFunctionCall1(numeric_scale, fcinfo.arg[0])) +
DatumGetInt32(DirectFunctionCall1(numeric_scale, fcinfo.arg[1]));
if (s == 0)
n = DirectFunctionCall2(numeric_trunc, n, 0);
}
return numeric_to_jnumber(DatumGetNumeric(n));
}
Datum
gpupreagg_corr_psum_xy(PG_FUNCTION_ARGS)
{
Assert(PG_NARGS() == 3);
/* Aggregate Filter */
if (PG_ARGISNULL(0) || !PG_GETARG_BOOL(0))
PG_RETURN_NULL();
/* NULL checks */
if (PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL();
/* calculation of X*X with overflow checks */
PG_RETURN_DATUM(DirectFunctionCall2(float8mul,
PG_GETARG_FLOAT8(1),
PG_GETARG_FLOAT8(2)));
}
Datum
_numeric_weighted_mean_final(PG_FUNCTION_ARGS)
{
WeightedMeanInternalState *state;
Datum total;
Datum zero = make_numeric(0);
state = PG_ARGISNULL(0)
? NULL
: (WeightedMeanInternalState *) PG_GETARG_POINTER(0);
/* No row has ever been processed. */
if (state == NULL)
return zero;
if (DatumGetBool(DirectFunctionCall2(numeric_eq,
zero, state->running_weight)))
total = zero;
else
total = DirectFunctionCall2(numeric_div,
state->running_sum, state->running_weight);
PG_RETURN_NUMERIC(total);
}
static inline
IP_P
ipaddr_transform_2d(Datum d1, Datum d2, PGFunction ip4func, PGFunction ip6func)
{
IP_P ipp = DatumGetIP_P(d1);
IP ip;
int af = ip_unpack(ipp, &ip);
switch (af)
{
case PGSQL_AF_INET:
ip.ip4 = DatumGetIP4(DirectFunctionCall2(ip4func, IP4GetDatum(ip.ip4), d2));
break;
case PGSQL_AF_INET6:
ip.ip6 = *(DatumGetIP6P(DirectFunctionCall2(ip6func, IP6PGetDatum(&ip.ip6), d2)));
break;
default:
ipaddr_internal_error();
}
return ip_pack(af, &ip);
}
Datum
ipaddr_minus_ipaddr(PG_FUNCTION_ARGS)
{
Datum minuend = PG_GETARG_DATUM(0);
Datum subtrahend = PG_GETARG_DATUM(1);
Datum res;
IP ip1;
IP ip2;
int af1 = ip_unpack(DatumGetIP_P(minuend), &ip1);
int af2 = ip_unpack(DatumGetIP_P(subtrahend), &ip2);
if (af1 != af2)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid mixing of IP address families")));
switch (af1)
{
case PGSQL_AF_INET:
res = DirectFunctionCall2(numeric_sub,
DirectFunctionCall1(ip4_cast_to_numeric,IP4GetDatum(ip1.ip4)),
DirectFunctionCall1(ip4_cast_to_numeric,IP4GetDatum(ip2.ip4)));
break;
case PGSQL_AF_INET6:
res = DirectFunctionCall2(numeric_sub,
DirectFunctionCall1(ip6_cast_to_numeric,IP6PGetDatum(&ip1.ip6)),
DirectFunctionCall1(ip6_cast_to_numeric,IP6PGetDatum(&ip2.ip6)));
break;
default:
ipaddr_internal_error();
}
PG_RETURN_DATUM(res);
}
static float8
gbt_ts_dist(const void *a, const void *b)
{
const Timestamp *aa = (const Timestamp *) a;
const Timestamp *bb = (const Timestamp *) b;
Interval *i;
if (TIMESTAMP_NOT_FINITE(*aa) || TIMESTAMP_NOT_FINITE(*bb))
return get_float8_infinity();
i = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi,
TimestampGetDatumFast(*aa),
TimestampGetDatumFast(*bb)));
return (float8) Abs(INTERVAL_TO_SEC(i));
}
