Datum
linterp_TimeADT(PG_FUNCTION_ARGS)
{
TimeADT y0;
TimeADT y1;
float8 p;
TimeADT result = 0;
bool eq_bounds = false;
bool eq_abscissas = false;
/* Common */
p = linterp_abscissa(fcinfo, &eq_bounds, &eq_abscissas);
/* Ordinate type specific code*/
y0 = PG_GETARG_TIMEADT(2);
y1 = PG_GETARG_TIMEADT(4);
if ( eq_bounds )
{
if ( eq_abscissas && (y0 == y1) )
result = y0;
else
PG_RETURN_NULL();
}
else
{
result = time_li_value(p, y0, y1);
}
PG_RETURN_TIMEADT(result);
}
Datum HASHAPI_Hash_1_time(PG_FUNCTION_ARGS)
{
int32 num_segs; /* number of segments */
TimeADT val1; /* time value */
unsigned int targetbucket; /* 0-based */
int16 algorithm; /* hashing algorithm */
Datum d1;
Oid oid;
/* Get number of segments */
num_segs = PG_GETARG_INT32(0);
/* Get hashing algoriithm */
algorithm = PG_GETARG_INT16(1);
/* Get the value to hash */
val1 = PG_GETARG_TIMEADT(2);
d1 = TimeADTGetDatum(val1);
/* create a CdbHash for this hash test. */
h = makeCdbHash(num_segs, algorithm);
/* init cdb hash */
cdbhashinit(h);
oid = TIMEOID;
cdbhash(h, d1, oid);
/* reduce the result hash value */
targetbucket = cdbhashreduce(h);
PG_RETURN_INT32(targetbucket); /* return target bucket (segID) */
}
Datum
gbt_time_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TimeADT query = PG_GETARG_TIMEADT(1);
timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key);
GBT_NUMKEY_R key;
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
key.lower = (GBT_NUMKEY *) & kkk->lower;
key.upper = (GBT_NUMKEY *) & kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
);
}
Datum
gbt_time_distance(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TimeADT query = PG_GETARG_TIMEADT(1);
/* Oid subtype = PG_GETARG_OID(3); */
timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key);
GBT_NUMKEY_R key;
key.lower = (GBT_NUMKEY *) &kkk->lower;
key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_FLOAT8(
gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), &tinfo)
);
}
Datum
gbt_time_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TimeADT query = PG_GETARG_TIMEADT(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key);
GBT_NUMKEY_R key;
/* All cases served by this function are exact */
*recheck = false;
key.lower = (GBT_NUMKEY *) &kkk->lower;
key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
);
}
/*
* linterp_abscissa
*
* Common code that checks arguments. The result is a floating point value
* representing what fraction of the distance x lies along the interval from
* x0 to x1. It can be negative or greater than one (extrapolation) though
* this isn't the intended use. If x0 == x1, then the fraction is not
* determined and the function returns 0 and sets *notnull false. In all
* other cases (except error exits) *notnull is set to true. An additional
* flag indicates whether the abscissa value is equal to the lower boundary
* value.
*/
static float8
linterp_abscissa(PG_FUNCTION_ARGS, bool *p_eq_bounds, bool *p_eq_abscissas)
{
Oid x_type;
Oid x0_type;
Oid x1_type;
Oid y0_type;
Oid y1_type;
float8 p = 0;
bool eq_bounds = false;
bool eq_abscissas = false;
/* The abscissa (x) arguments are nominally declared anyelement.
* All the type checking is up to us. We insist that the types
* are exactly alike. Explicit casts may be needed.
*/
x_type = get_fn_expr_argtype(fcinfo->flinfo, 0);
x0_type = get_fn_expr_argtype(fcinfo->flinfo, 1);
x1_type = get_fn_expr_argtype(fcinfo->flinfo, 3);
if (!OidIsValid(x_type)||!OidIsValid(x0_type)||!OidIsValid(x1_type))
{
elog(ERROR, "could not determine argument data types");
}
if ( x_type!=x0_type || x_type!=x1_type )
{
elog(ERROR, "abscissa types unequal");
}
/* The ordinate (y) arguments are specifically declared in the SQL
* function declaration. Here we just check and insist they are
* identical.
*/
y0_type = get_fn_expr_argtype(fcinfo->flinfo, 2);
y1_type = get_fn_expr_argtype(fcinfo->flinfo, 4);
if ( y0_type != y1_type )
{
elog(ERROR, "mismatched ordinate types");
}
switch (x_type)
{
case INT8OID:
{
float8 x = (float8)PG_GETARG_INT64(0);
float8 x0 = (float8)PG_GETARG_INT64(1);
float8 x1 = (float8)PG_GETARG_INT64(3);
if ( x1 == x0 )
{
eq_bounds = true;
eq_abscissas = ( x == x0 );
}
else
p = (x-x0)/(x1-x0);
}
break;
case INT4OID:
{
float8 x = (float8)PG_GETARG_INT32(0);
float8 x0 = (float8)PG_GETARG_INT32(1);
float8 x1 = (float8)PG_GETARG_INT32(3);
if ( x1 == x0 )
{
eq_bounds = true;
eq_abscissas = ( x == x0 );
}
else
p = (x-x0)/(x1-x0);
}
break;
case INT2OID:
{
float8 x = (float8)PG_GETARG_INT16(0);
float8 x0 = (float8)PG_GETARG_INT16(1);
float8 x1 = (float8)PG_GETARG_INT16(3);
if ( x1 == x0 )
{
eq_bounds = true;
eq_abscissas = ( x == x0 );
}
else
p = (x-x0)/(x1-x0);
}
break;
case FLOAT4OID:
{
float8 x = (float8)PG_GETARG_FLOAT4(0);
float8 x0 = (float8)PG_GETARG_FLOAT4(1);
float8 x1 = (float8)PG_GETARG_FLOAT4(3);
if ( x1 == x0 )
{
eq_bounds = true;
eq_abscissas = ( x == x0 );
}
else
p = (x-x0)/(x1-x0);
}
break;
case FLOAT8OID:
{
float8 x = PG_GETARG_FLOAT8(0);
float8 x0 = PG_GETARG_FLOAT8(1);
float8 x1 = PG_GETARG_FLOAT8(3);
if ( x1 == x0 )
{
eq_bounds = true;
eq_abscissas = ( x == x0 );
}
else
p = (x-x0)/(x1-x0);
}
break;
case DATEOID:
{
DateADT x = PG_GETARG_DATEADT(0);
DateADT x0 = PG_GETARG_DATEADT(1);
DateADT x1 = PG_GETARG_DATEADT(3);
int32 x_x0 = date_diff(x, x0);
int32 x1_x0 = date_diff(x1, x0);
if ( x1 == x0 )
{
eq_bounds = true;
eq_abscissas = ( x_x0 == 0 );
}
else
p = ((float8)x_x0)/((float8)x1_x0);
}
break;
case TIMEOID:
{
TimeADT x = PG_GETARG_TIMEADT(0);
TimeADT x0 = PG_GETARG_TIMEADT(1);
TimeADT x1 = PG_GETARG_TIMEADT(3);
p = time_li_fraction(x, x0, x1, &eq_bounds, &eq_abscissas);
}
break;
case TIMESTAMPOID:
{
Timestamp x = PG_GETARG_TIMESTAMP(0);
Timestamp x0 = PG_GETARG_TIMESTAMP(1);
Timestamp x1 = PG_GETARG_TIMESTAMP(3);
p = timestamp_li_fraction(x, x0, x1, &eq_bounds, &eq_abscissas);
}
break;
case TIMESTAMPTZOID:
{
TimestampTz x = PG_GETARG_TIMESTAMPTZ(0);
TimestampTz x0 = PG_GETARG_TIMESTAMPTZ(1);
TimestampTz x1 = PG_GETARG_TIMESTAMPTZ(3);
p = timestamptz_li_fraction(x, x0, x1, &eq_bounds, &eq_abscissas);
}
break;
case INTERVALOID:
{
Interval * x = PG_GETARG_INTERVAL_P(0);
Interval * x0 = PG_GETARG_INTERVAL_P(1);
Interval * x1 = PG_GETARG_INTERVAL_P(3);
p = interval_li_fraction(x, x0, x1, &eq_bounds, &eq_abscissas);
}
break;
case NUMERICOID:
{
Numeric x = PG_GETARG_NUMERIC(0);
Numeric x0 = PG_GETARG_NUMERIC(1);
Numeric x1 = PG_GETARG_NUMERIC(3);
p = numeric_li_fraction(x, x0, x1, &eq_bounds, &eq_abscissas);
}
break;
default:
elog(ERROR, "abscissa type not supported");
}
if ( p_eq_bounds )
*p_eq_bounds = eq_bounds;
if ( p_eq_abscissas )
*p_eq_abscissas = eq_abscissas;
return p;
}
