Datum
adaptive_get_estimate(PG_FUNCTION_ARGS)
{
int estimate;
AdaptiveCounter ac = (AdaptiveCounter)PG_GETARG_BYTEA_P(0);
/* in-place update works only if executed as aggregate */
estimate = ac_estimate(ac);
/* return the updated bytea */
PG_RETURN_FLOAT4(estimate);
}
Datum
ts_rankcd_ttf(PG_FUNCTION_ARGS)
{
TSVector txt = PG_GETARG_TSVECTOR(0);
TSQuery query = PG_GETARG_TSQUERY(1);
int method = PG_GETARG_INT32(2);
float res;
res = calc_rank_cd(getWeights(NULL), txt, query, method);
PG_FREE_IF_COPY(txt, 0);
PG_FREE_IF_COPY(query, 1);
PG_RETURN_FLOAT4(res);
}
Datum
word_similarity_dist_commutator_op(PG_FUNCTION_ARGS)
{
text *in1 = PG_GETARG_TEXT_PP(0);
text *in2 = PG_GETARG_TEXT_PP(1);
float4 res;
res = calc_word_similarity(VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
false);
PG_FREE_IF_COPY(in1, 0);
PG_FREE_IF_COPY(in2, 1);
PG_RETURN_FLOAT4(1.0 - res);
}
Datum
strict_word_similarity_dist_op(PG_FUNCTION_ARGS)
{
text *in1 = PG_GETARG_TEXT_PP(0);
text *in2 = PG_GETARG_TEXT_PP(1);
float4 res;
res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
WORD_SIMILARITY_STRICT);
PG_FREE_IF_COPY(in1, 0);
PG_FREE_IF_COPY(in2, 1);
PG_RETURN_FLOAT4(1.0 - res);
}
Datum
ts_rankcd_wtt(PG_FUNCTION_ARGS)
{
ArrayType *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
TSVector txt = PG_GETARG_TSVECTOR(1);
TSQuery query = PG_GETARG_TSQUERY(2);
float res;
res = calc_rank_cd(getWeights(win), txt, query, DEF_NORM_METHOD);
PG_FREE_IF_COPY(win, 0);
PG_FREE_IF_COPY(txt, 1);
PG_FREE_IF_COPY(query, 2);
PG_RETURN_FLOAT4(res);
}
Datum
ts_rank_wttf(PG_FUNCTION_ARGS)
{
ArrayType *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
TSVector txt = PG_GETARG_TSVECTOR(1);
TSQuery query = PG_GETARG_TSQUERY(2);
int method = PG_GETARG_INT32(3);
float res;
res = calc_rank(getWeights(win), txt, query, method);
PG_FREE_IF_COPY(win, 0);
PG_FREE_IF_COPY(txt, 1);
PG_FREE_IF_COPY(query, 2);
PG_RETURN_FLOAT4(res);
}
Datum
rank(PG_FUNCTION_ARGS)
{
ArrayType *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_DATUM(2));
int method = DEF_NORM_METHOD;
float res = 0.0;
float ws[lengthof(weights)];
float4 *arrdata;
int i;
if (ARR_NDIM(win) != 1)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array of weight must be one-dimensional")));
if (ARRNELEMS(win) < lengthof(weights))
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array of weight is too short")));
if (ARR_HASNULL(win))
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("array of weight must not contain nulls")));
arrdata = (float4 *) ARR_DATA_PTR(win);
for (i = 0; i < lengthof(weights); i++)
{
ws[i] = (arrdata[i] >= 0) ? arrdata[i] : weights[i];
if (ws[i] > 1.0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("weight out of range")));
}
if (PG_NARGS() == 4)
method = PG_GETARG_INT32(3);
res = calc_rank(ws, txt, query, method);
PG_FREE_IF_COPY(win, 0);
PG_FREE_IF_COPY(txt, 1);
PG_FREE_IF_COPY(query, 2);
PG_RETURN_FLOAT4(res);
}
/**
* Implementation of sql function with the same name
*
* create function
* read_float_from_file(id bigint, pos int) returns void
*
* read a float from the given file. pos is the index in the file, multiplied
* by sizeof(float). This means that read_float_from_file(x, 4) will read bytes
* [16,20), and return them as a float.
*/
Datum read_float_from_file(PG_FUNCTION_ARGS)
{
if ( PG_ARGISNULL(0) or PG_ARGISNULL(1) )
ereport(ERROR, (errcode( ERRCODE_RAISE_EXCEPTION ), errmsg("NULL argument not allowed")));
int64 id = PG_GETARG_INT64(0);
int position = PG_GETARG_INT32(1);
float ret = -1;
// WARNING:
// Do not use any postgres functionality within this macro
// It will cause a resource leak.
HANDLE_EXCEPTIONS(ret = readFloatFromFile(id, position));
PG_RETURN_FLOAT4(ret);
}
Datum
rank_def(PG_FUNCTION_ARGS)
{
tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
float res = 0.0;
int method = DEF_NORM_METHOD;
if (PG_NARGS() == 3)
method = PG_GETARG_INT32(2);
res = calc_rank(weights, txt, query, method);
PG_FREE_IF_COPY(txt, 0);
PG_FREE_IF_COPY(query, 1);
PG_RETURN_FLOAT4(res);
}
Datum
_float4_weighted_mean_final(PG_FUNCTION_ARGS)
{
float *state;
float total;
state = PG_ARGISNULL(0)
? NULL
: (float *) PG_GETARG_POINTER(0);
if (state == NULL || state[1] == 0.0)
return 0;
total = state[0]/state[1];
PG_RETURN_FLOAT4(total);
}
Datum
smithwatermangotoh(PG_FUNCTION_ARGS)
{
char *a, *b;
float maxvalue;
float4 res;
a = DatumGetPointer(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
b = DatumGetPointer(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
if (strlen(a) > PGS_MAX_STR_LEN || strlen(b) > PGS_MAX_STR_LEN)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument exceeds the maximum length of %d bytes",
PGS_MAX_STR_LEN)));
maxvalue = (float) min2(strlen(a), strlen(b));
res = _smithwatermangotoh(a, b);
elog(DEBUG1, "is normalized: %d", pgs_swg_is_normalized);
elog(DEBUG1, "maximum length: %.3f", maxvalue);
elog(DEBUG1, "swgdistance(%s, %s) = %.3f", a, b, res);
if (maxvalue == 0)
{
res = 1.0;
}
if (pgs_swg_is_normalized)
{
if (PGS_SW_MAX_COST > (-1 * PGS_SW_GAP_COST))
maxvalue *= PGS_SW_MAX_COST;
else
maxvalue *= -1 * PGS_SW_GAP_COST;
/* paranoia ? */
if (maxvalue == 0.0)
res = 1.0;
else
res = (res / maxvalue);
}
elog(DEBUG1, "swg(%s, %s) = %.3f", a, b, res);
PG_RETURN_FLOAT4(res);
}
/*
* Deprecated function.
* Use "pg_trgm.similarity_threshold" GUC variable instead of this function.
*/
Datum
set_limit(PG_FUNCTION_ARGS)
{
float4 nlimit = PG_GETARG_FLOAT4(0);
char *nlimit_str;
Oid func_out_oid;
bool is_varlena;
getTypeOutputInfo(FLOAT4OID, &func_out_oid, &is_varlena);
nlimit_str = OidOutputFunctionCall(func_out_oid, Float4GetDatum(nlimit));
SetConfigOption("pg_trgm.similarity_threshold", nlimit_str,
PGC_USERSET, PGC_S_SESSION);
PG_RETURN_FLOAT4(similarity_threshold);
}
Datum
float4div(PG_FUNCTION_ARGS)
{
float4 arg1 = PG_GETARG_FLOAT4(0);
float4 arg2 = PG_GETARG_FLOAT4(1);
double result;
if (arg2 == 0.0)
ereport(ERROR,
(errcode(ERRCODE_DIVISION_BY_ZERO),
errmsg("division by zero")));
/* Do division in float8, then check for overflow */
result = (float8) arg1 / (float8) arg2;
CheckFloat4Val(result);
PG_RETURN_FLOAT4((float4) result);
}
Datum decimal64_float4(PG_FUNCTION_ARGS)
{
PGDecimal64 a = PG_GETARG_DECIMAL64(0);
char s[DECDOUBLE_String];
char *endp = 0;
float f;
decDoubleToString(&a, s);
errno = 0;
f = strtof(s, &endp);
if (endp == s || errno != 0) {
elog(ERROR, "cannot convert decimal64 to float4");
}
PG_RETURN_FLOAT4(f);
}
Datum
ln_airmass (PG_FUNCTION_ARGS)
{
struct ln_equ_posn pos;
struct ln_lnlat_posn obs;
struct ln_hrz_posn hrz;
// ra, dec, lng, lat, JD
if (PG_ARGISNULL (0) || PG_ARGISNULL (1)
|| PG_ARGISNULL (2) || PG_ARGISNULL (3) || PG_ARGISNULL (4))
PG_RETURN_NULL ();
pos.ra = PG_GETARG_FLOAT8 (0);
pos.dec = PG_GETARG_FLOAT8 (1);
obs.lng = PG_GETARG_FLOAT8 (2);
obs.lat = PG_GETARG_FLOAT8 (3);
ln_get_hrz_from_equ (&pos, &obs, PG_GETARG_FLOAT8 (4), &hrz);
PG_RETURN_FLOAT4 (ln_get_airmass (hrz.alt, 750));
}
Datum
similarity(PG_FUNCTION_ARGS)
{
text *in1 = PG_GETARG_TEXT_P(0);
text *in2 = PG_GETARG_TEXT_P(1);
TRGM *trg1,
*trg2;
float4 res;
trg1 = generate_trgm(VARDATA(in1), VARSIZE(in1) - VARHDRSZ);
trg2 = generate_trgm(VARDATA(in2), VARSIZE(in2) - VARHDRSZ);
res = cnt_sml(trg1, trg2);
pfree(trg1);
pfree(trg2);
PG_FREE_IF_COPY(in1, 0);
PG_FREE_IF_COPY(in2, 1);
PG_RETURN_FLOAT4(res);
}
/*
* float4in - converts "num" to float
* restricted syntax:
* {<sp>} [+|-] {digit} [.{digit}] [<exp>]
* where <sp> is a space, digit is 0-9,
* <exp> is "e" or "E" followed by an integer.
*/
Datum
float4in(PG_FUNCTION_ARGS)
{
char *num = PG_GETARG_CSTRING(0);
double val;
char *endptr;
errno = 0;
val = strtod(num, &endptr);
if (*endptr != '\0')
{
/*
* XXX we should accept "Infinity" and "-Infinity" too, but what
* are the correct values to assign? HUGE_VAL will provoke an
* error from CheckFloat4Val.
*/
if (strcasecmp(num, "NaN") == 0)
val = NAN;
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type real: \"%s\"",
num)));
}
else
{
if (errno == ERANGE)
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("\"%s\" is out of range for type real", num)));
}
/*
* if we get here, we have a legal double, still need to check to see
* if it's a legal float
*/
CheckFloat4Val(val);
PG_RETURN_FLOAT4((float4) val);
}
Datum ts_rank_idf(PG_FUNCTION_ARGS)
{
char **documentTokenList, **queryTokenList;
char *document, *query;
int documentWords, queryWords;
int i, j;
long documentCount;
float score;
document = text_to_cstring(PG_GETARG_TEXT_P(0));
query = text_to_cstring(PG_GETARG_TEXT_P(1));
documentWords = tokenize(document, &documentTokenList);
queryWords = tokenize(query, &queryTokenList);
documentCount = getDocumentCount();
score = 0.0;
for(i = 0; i < queryWords; i++)
{
for(j = 0; j < documentWords; j++)
{
if(!strcmp(queryTokenList[i], documentTokenList[j]))
score += log((float) documentCount / getTokenFrequency(queryTokenList[i]));
}
}
pfree(document);
pfree(query);
for(i = 0; i < queryWords; i++)
pfree(queryTokenList[i]);
for(i = 0; i < documentWords; i++)
pfree(documentTokenList[i]);
pfree(queryTokenList);
pfree(documentTokenList);
PG_RETURN_FLOAT4(score);
}
Datum
xpath_number(PG_FUNCTION_ARGS)
{
xmlChar *xpath;
int32 pathsize;
text
*xpathsupp;
float4 fRes;
xmlXPathObjectPtr res;
/* PG_GETARG_TEXT_P(0) is document buffer */
xpathsupp = PG_GETARG_TEXT_P(1); /* XPath expression */
pathsize = VARSIZE(xpathsupp) - VARHDRSZ;
xpath = pgxml_texttoxmlchar(xpathsupp);
res = pgxml_xpath(PG_GETARG_TEXT_P(0), xpath);
pfree(xpath);
if (res == NULL)
{
xmlCleanupParser();
PG_RETURN_NULL();
}
fRes = xmlXPathCastToNumber(res);
xmlCleanupParser();
if (xmlXPathIsNaN(fRes))
PG_RETURN_NULL();
PG_RETURN_FLOAT4(fRes);
}
Datum getmass(PG_FUNCTION_ARGS){
Datum mol_datum = PG_GETARG_DATUM(0);
float result = 0;
PG_BINGO_BEGIN
{
BingoPgCommon::BingoSessionHandler bingo_handler(fcinfo->flinfo->fn_oid);
bingo_handler.setFunctionName("getmass");
BingoPgText mol_text(mol_datum);
int buf_len, bingo_res;
const char* buf = mol_text.getText(buf_len);
bingo_res = mangoMass(buf, buf_len, 0, &result);
if(bingo_res < 1) {
CORE_HANDLE_WARNING(0, 1, "bingo.getmass", bingoGetError());
PG_RETURN_NULL();
}
}
PG_BINGO_END
PG_RETURN_FLOAT4(result);
}
Datum BOX2DFLOAT4_xmin(PG_FUNCTION_ARGS)
{
BOX2DFLOAT4 *box = (BOX2DFLOAT4 *)PG_GETARG_POINTER(0);
PG_RETURN_FLOAT4(box->xmin);
}
Datum
show_limit(PG_FUNCTION_ARGS)
{
PG_RETURN_FLOAT4(trgm_limit);
}
Datum BOX2DFLOAT4_ymax(PG_FUNCTION_ARGS)
{
BOX2DFLOAT4 *box = (BOX2DFLOAT4 *)PG_GETARG_POINTER(0);
PG_RETURN_FLOAT4(box->ymax);
}
/*
* Deprecated function.
* Use "pg_trgm.similarity_threshold" GUC variable instead of this function.
*/
Datum
show_limit(PG_FUNCTION_ARGS)
{
PG_RETURN_FLOAT4(similarity_threshold);
}
Datum
cosine(PG_FUNCTION_ARGS)
{
char *a, *b;
TokenList *s, *t;
int atok, btok, comtok, alltok;
float4 res;
a = DatumGetPointer(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
b = DatumGetPointer(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
if (strlen(a) > PGS_MAX_STR_LEN || strlen(b) > PGS_MAX_STR_LEN)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument exceeds the maximum length of %d bytes",
PGS_MAX_STR_LEN)));
/* sets */
s = initTokenList(1);
t = initTokenList(1);
switch (pgs_cosine_tokenizer)
{
case PGS_UNIT_WORD:
tokenizeBySpace(s, a);
tokenizeBySpace(t, b);
break;
case PGS_UNIT_GRAM:
tokenizeByGram(s, a);
tokenizeByGram(t, b);
break;
case PGS_UNIT_CAMELCASE:
tokenizeByCamelCase(s, a);
tokenizeByCamelCase(t, b);
break;
case PGS_UNIT_ALNUM: /* default */
default:
tokenizeByNonAlnum(s, a);
tokenizeByNonAlnum(t, b);
break;
}
elog(DEBUG3, "Token List A");
printToken(s);
elog(DEBUG3, "Token List B");
printToken(t);
atok = s->size;
btok = t->size;
/* combine the sets */
switch (pgs_cosine_tokenizer)
{
case PGS_UNIT_WORD:
tokenizeBySpace(s, b);
break;
case PGS_UNIT_GRAM:
tokenizeByGram(s, b);
break;
case PGS_UNIT_CAMELCASE:
tokenizeByCamelCase(s, b);
break;
case PGS_UNIT_ALNUM: /* default */
default:
tokenizeByNonAlnum(s, b);
break;
}
elog(DEBUG3, "All Token List");
printToken(s);
alltok = s->size;
destroyTokenList(s);
destroyTokenList(t);
comtok = atok + btok - alltok;
elog(DEBUG1, "is normalized: %d", pgs_cosine_is_normalized);
elog(DEBUG1, "token list A size: %d", atok);
elog(DEBUG1, "token list B size: %d", btok);
elog(DEBUG1, "all tokens size: %d", alltok);
elog(DEBUG1, "common tokens size: %d", comtok);
/* normalized and unnormalized version are the same */
res = (float) comtok / (sqrt(atok) * sqrt(btok));
PG_RETURN_FLOAT4(res);
}
