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); }