static int
pg_callable_func(lua_State *L)
{
MemoryContext m;
int i;
FunctionCallInfoData fcinfo;
Lua_pgfunc *fi;
fi = (Lua_pgfunc *) lua_touserdata(L, lua_upvalueindex(1));
InitFunctionCallInfoData(fcinfo, &fi->fi, fi->numargs, InvalidOid, NULL, NULL);
if(tmpcontext_usage> RESET_CONTEXT_AFTER ){
MemoryContextReset(tmpcontext);
tmpcontext_usage = 0;
}
++tmpcontext_usage;
m = MemoryContextSwitchTo(tmpcontext);
for (i=0; i<fi->numargs; ++i){
fcinfo.arg[i] = luaP_todatum(L, fi->argtypes[i], 0, &fcinfo.argnull[i], i+1);
}
if(!fi->options.only_internal && fi->options.throwable){
SPI_push();
PG_TRY();
{
Datum d = FunctionCallInvoke(&fcinfo);
MemoryContextSwitchTo(m);
if (fcinfo.isnull) {
lua_pushnil(L);
} else {
luaP_pushdatum(L, d, fi->prorettype);
}
SPI_pop();
}
PG_CATCH();
{
lua_pop(L, lua_gettop(L));
push_spi_error(L, m); /*context switch to m inside push_spi_error*/
SPI_pop();
return lua_error(L);
}PG_END_TRY();
}else{
Datum d = FunctionCallInvoke(&fcinfo);
MemoryContextSwitchTo(m);
if (fcinfo.isnull) {
lua_pushnil(L);
} else {
luaP_pushdatum(L, d, fi->prorettype);
}
}
return 1;
}
hdfsFS
HdfsConnect(FsysName protocol, char * host, uint16_t port, char *ccname, void *token)
{
FunctionCallInfoData fcinfo;
FileSystemUdfData fsysUdf;
FmgrInfo *fsysFunc = FsysInterfaceGetFunc(protocol, FSYS_FUNC_CONNECT);
#ifdef USE_ASSERT_CHECKING
if (testmode_fault(gp_fsys_fault_inject_percent))
return NULL;
#endif
fsysUdf.type = T_FileSystemFunctionData;
fsysUdf.fsys_host = host;
fsysUdf.fsys_port = port;
fsysUdf.fsys_hdfs = NULL;
fsysUdf.fsys_ccname = ccname;
fsysUdf.fsys_token = token;
InitFunctionCallInfoData(/* FunctionCallInfoData */ fcinfo,
/* FmgrInfo */ fsysFunc,
/* nArgs */ 0,
/* Call Context */ (Node *) (&fsysUdf),
/* ResultSetInfo */ NULL);
FunctionCallInvoke(&fcinfo);
return FSYS_UDF_GET_HDFS(&fcinfo);
}
/*
* def load_module(fullname) -> types.ModuleType
*
* Evaluate the function's code in a new module
* or if the fullname exists in sys.modules, return
* the existing module. [PEP302]
*
* This code must go through pl_handler in order to properly load the
* module. The execution context can dictate much about what happens during
* load time.
*
* i.e., tricky shit happens here. It may be preferrable to make the execution
* context rigging more accessible, but for now, it's the handler's job.
*/
static PyObj
load_module(PyObj self, PyObj args, PyObj kw)
{
MemoryContext former = CurrentMemoryContext;
volatile PyObj rob = NULL;
FmgrInfo flinfo;
FunctionCallInfoData fcinfo;
if (invalid_fullname(self, args, kw))
return(NULL);
/*
* Disallow execution of "anonymous" functions.
*/
flinfo.fn_addr = PyPgFunction_GetPGFunction(self);
flinfo.fn_oid = PyPgFunction_GetOid(self);
flinfo.fn_retset = false;
if (flinfo.fn_addr == NULL || flinfo.fn_oid == InvalidOid)
{
PyErr_SetString(PyExc_TypeError, "internal functions cannot be preloaded");
return(NULL);
}
flinfo.fn_nargs = -1;
flinfo.fn_extra = NULL;
flinfo.fn_mcxt = CurrentMemoryContext;
flinfo.fn_expr = NULL;
fcinfo.nargs = -1;
fcinfo.flinfo = &flinfo;
fcinfo.context = NULL;
fcinfo.resultinfo = NULL;
/*
* Better be true afterwards.
*/
fcinfo.isnull = false;
SPI_push();
PG_TRY();
{
rob = (PyObj) DatumGetPointer(FunctionCallInvoke(&fcinfo));
}
PG_CATCH();
{
rob = NULL;
PyErr_SetPgError(false);
}
PG_END_TRY();
SPI_pop();
MemoryContextSwitchTo(former);
if (fcinfo.isnull == false)
{
PyErr_SetString(PyExc_RuntimeError,
"function module load protocol did not set isnull");
rob = NULL;
}
Py_XINCREF(rob);
return(rob);
}
int
HdfsSeek(FsysName protocol, hdfsFS fileSystem, hdfsFile file, int64_t desiredPos)
{
FunctionCallInfoData fcinfo;
FileSystemUdfData fsysUdf;
FmgrInfo *fsysFunc = FsysInterfaceGetFunc(protocol, FSYS_FUNC_SEEK);
#ifdef USE_ASSERT_CHECKING
if (testmode_fault(gp_fsys_fault_inject_percent))
return -1;
#endif
fsysUdf.type = T_FileSystemFunctionData;
fsysUdf.fsys_hdfs = fileSystem;
fsysUdf.fsys_hfile = file;
fsysUdf.fsys_pos = desiredPos;
InitFunctionCallInfoData(/* FunctionCallInfoData */ fcinfo,
/* FmgrInfo */ fsysFunc,
/* nArgs */ 0,
/* Call Context */ (Node *) (&fsysUdf),
/* ResultSetInfo */ NULL);
Datum d = FunctionCallInvoke(&fcinfo);
return DatumGetInt32(d);
}
static int pgfunc_rowsaux (lua_State *L) {
ReturnSetInfo *rsinfo;
FunctionCallInfoData *fcinfo;
Datum d;
Oid prorettype;
Lua_pgfunc_srf *srfi;
srfi = (Lua_pgfunc_srf *) lua_touserdata(L, lua_upvalueindex(1));
rsinfo = &srfi->rsinfo;
fcinfo = &srfi->fcinfo;
prorettype = srfi->prorettype;
d = FunctionCallInvoke(fcinfo);
if ((!fcinfo->isnull)&&(rsinfo->isDone != ExprEndResult)){
luaP_pushdatum(L, d, prorettype);
return 1;
}
lua_pushnil(L);
return 1;
}
int
HdfsWrite(FsysName protocol, hdfsFS fileSystem, hdfsFile file, const void * buffer, int length)
{
FunctionCallInfoData fcinfo;
FileSystemUdfData fsysUdf;
FmgrInfo *fsysFunc = FsysInterfaceGetFunc(protocol, FSYS_FUNC_WRITE);
#ifdef USE_ASSERT_CHECKING
if (testmode_fault(gp_fsys_fault_inject_percent))
return -1;
#endif
fsysUdf.type = T_FileSystemFunctionData;
fsysUdf.fsys_hdfs = fileSystem;
fsysUdf.fsys_hfile = file;
fsysUdf.fsys_databuf = (char *) buffer;
fsysUdf.fsys_maxbytes = length;
InitFunctionCallInfoData(/* FunctionCallInfoData */ fcinfo,
/* FmgrInfo */ fsysFunc,
/* nArgs */ 0,
/* Call Context */ (Node *) (&fsysUdf),
/* ResultSetInfo */ NULL);
Datum d = FunctionCallInvoke(&fcinfo);
return DatumGetInt32(d);
}
int HdfsTruncate(FsysName protocol, hdfsFS fileSystem, char * path, int64_t size)
{
FunctionCallInfoData fcinfo;
FileSystemUdfData fsysUdf;
FmgrInfo *fsysFunc = FsysInterfaceGetFunc(protocol, FSYS_FUNC_TRUNCATE);
#ifdef USE_ASSERT_CHECKING
if (testmode_fault(gp_fsys_fault_inject_percent))
return -1;
#endif
fsysUdf.type = T_FileSystemFunctionData;
fsysUdf.fsys_hdfs = fileSystem;
fsysUdf.fsys_filepath = path;
fsysUdf.fsys_pos = size;
InitFunctionCallInfoData(/* FunctionCallInfoData */ fcinfo,
/* FmgrInfo */ fsysFunc,
/* nArgs */ 0,
/* Call Context */ (Node *) (&fsysUdf),
/* ResultSetInfo */ NULL);
Datum d = FunctionCallInvoke(&fcinfo);
return DatumGetInt32(d);
}
hdfsFile HdfsOpenFile(FsysName protocol, hdfsFS fileSystem, char * path, int flags,
int bufferSize, short replication, int64_t blocksize)
{
FunctionCallInfoData fcinfo;
FileSystemUdfData fsysUdf;
FmgrInfo *fsysFunc = FsysInterfaceGetFunc(protocol, FSYS_FUNC_OPEN);
#ifdef USE_ASSERT_CHECKING
if (testmode_fault(gp_fsys_fault_inject_percent))
return NULL;
#endif
fsysUdf.type = T_FileSystemFunctionData;
fsysUdf.fsys_hdfs = fileSystem;
fsysUdf.fsys_filepath = path;
fsysUdf.fsys_fileflags = flags;
fsysUdf.fsys_filebufsize = bufferSize;
fsysUdf.fsys_replication = replication;
fsysUdf.fsys_fileblksize = blocksize;
fsysUdf.fsys_hfile = NULL;
InitFunctionCallInfoData(/* FunctionCallInfoData */ fcinfo,
/* FmgrInfo */ fsysFunc,
/* nArgs */ 0,
/* Call Context */ (Node *) (&fsysUdf),
/* ResultSetInfo */ NULL);
FunctionCallInvoke(&fcinfo);
return FSYS_UDF_GET_HFILE(&fcinfo);
}
static void
transform_receive(TupleTableSlot *slot, DestReceiver *self)
{
TransformState *t = (TransformState *) self;
MemoryContext old = MemoryContextSwitchTo(ContQueryBatchContext);
if (t->tg_rel == NULL)
t->tg_rel = heap_open(t->cont_query->matrelid, AccessShareLock);
if (t->cont_query->tgfn != PIPELINE_STREAM_INSERT_OID)
{
TriggerData *cxt = (TriggerData *) t->trig_fcinfo->context;
Assert(t->trig_fcinfo);
cxt->tg_relation = t->tg_rel;
cxt->tg_trigtuple = ExecCopySlotTuple(slot);
FunctionCallInvoke(t->trig_fcinfo);
heap_freetuple(cxt->tg_trigtuple);
cxt->tg_trigtuple = NULL;
}
else
{
if (t->tups == NULL)
{
Assert(t->nmaxtups == 0);
Assert(t->ntups == 0);
t->nmaxtups = continuous_query_batch_size / 8;
t->tups = palloc(sizeof(HeapTuple) * t->nmaxtups);
}
if (t->ntups == t->nmaxtups)
{
t->nmaxtups *= 2;
t->tups = repalloc(t->tups, sizeof(HeapTuple) * t->nmaxtups);
}
t->tups[t->ntups] = ExecCopySlotTuple(slot);
t->ntups++;
if (synchronous_stream_insert && t->acks == NULL)
t->acks = InsertBatchAckCreate(t->cont_exec->yielded_msgs, &t->nacks);
}
MemoryContextSwitchTo(old);
}
/*
* Shim function for calling an old-style comparator
*
* This is essentially an inlined version of FunctionCall2Coll(), except
* we assume that the FunctionCallInfoData was already mostly set up by
* PrepareSortSupportComparisonShim.
*/
static int
comparison_shim(Datum x, Datum y, SortSupport ssup)
{
SortShimExtra *extra = (SortShimExtra *) ssup->ssup_extra;
Datum result;
extra->fcinfo.arg[0] = x;
extra->fcinfo.arg[1] = y;
/* just for paranoia's sake, we reset isnull each time */
extra->fcinfo.isnull = false;
result = FunctionCallInvoke(&extra->fcinfo);
/* Check for null result, since caller is clearly not expecting one */
if (extra->fcinfo.isnull)
elog(ERROR, "function %u returned NULL", extra->flinfo.fn_oid);
return result;
}
int HdfsFreeFileInfo(FsysName protocol, hdfsFileInfo * info, int numEntries)
{
FunctionCallInfoData fcinfo;
FileSystemUdfData fsysUdf;
FmgrInfo *fsysFunc = FsysInterfaceGetFunc(protocol, FSYS_FUNC_FREEFILEINFO);
fsysUdf.type = T_FileSystemFunctionData;
fsysUdf.fsys_fileinfo = info;
fsysUdf.fsys_fileinfonum = numEntries;
InitFunctionCallInfoData(/* FunctionCallInfoData */ fcinfo,
/* FmgrInfo */ fsysFunc,
/* nArgs */ 0,
/* Call Context */ (Node *) (&fsysUdf),
/* ResultSetInfo */ NULL);
Datum d = FunctionCallInvoke(&fcinfo);
return DatumGetInt32(d);
}
hdfsFileInfo * HdfsGetPathInfo(FsysName protocol, hdfsFS fileSystem, char * path)
{
FunctionCallInfoData fcinfo;
FileSystemUdfData fsysUdf;
FmgrInfo *fsysFunc = FsysInterfaceGetFunc(protocol, FSYS_FUNC_GETPATHINFO);
fsysUdf.type = T_FileSystemFunctionData;
fsysUdf.fsys_hdfs = fileSystem;
fsysUdf.fsys_filepath = path;
fsysUdf.fsys_fileinfo = NULL;
InitFunctionCallInfoData(/* FunctionCallInfoData */ fcinfo,
/* FmgrInfo */ fsysFunc,
/* nArgs */ 0,
/* Call Context */ (Node *) (&fsysUdf),
/* ResultSetInfo */ NULL);
(void) FunctionCallInvoke(&fcinfo);
return FSYS_UDF_GET_FILEINFO(&fcinfo);
}
/*
* compare_keys
*/
static int
compare_keys(KeyedAggState *state, KeyValue *kv, Datum incoming, bool incoming_null, Oid collation, bool *result_null)
{
TypeCacheEntry *type = state->key_type;
FunctionCallInfoData cmp_fcinfo;
int result;
if (incoming_null || KV_KEY_IS_NULL(kv))
{
*result_null = true;
return 0;
}
InitFunctionCallInfoData(cmp_fcinfo, &type->cmp_proc_finfo, 2, collation, NULL, NULL);
cmp_fcinfo.arg[0] = kv->key;
cmp_fcinfo.argnull[0] = KV_KEY_IS_NULL(kv);
cmp_fcinfo.arg[1] = incoming;
cmp_fcinfo.argnull[1] = incoming_null;
result = DatumGetInt32(FunctionCallInvoke(&cmp_fcinfo));
*result_null = cmp_fcinfo.isnull;
return result;
}
/*
* Python only supports prefix unary operators.
*/
static PyObj
unary_operate(const char *op, PyObj right)
{
PyObj rob = NULL;
Datum dright = PyPgObject_GetDatum(right);
Oid right_oid = PyPgType_GetOid(Py_TYPE(right));
Py_ALLOCATE_OWNER();
{
PyObj rtype;
Operator opt;
volatile Datum rd = 0;
List * volatile namelist = NULL;
PG_TRY();
{
struct FmgrInfo flinfo = {0,};
struct FunctionCallInfoData fcinfo = {0,};
Form_pg_operator ops;
Oid declared, result_type, fn_oid;
namelist = stringToQualifiedNameList(op);
opt = oper(NULL, (List *) namelist, InvalidOid, right_oid, false, 1);
ops = (Form_pg_operator) GETSTRUCT(opt);
fn_oid = ops->oprcode;
declared = ops->oprright;
result_type = ops->oprresult;
ReleaseSysCache((HeapTuple) opt);
result_type = enforce_generic_type_consistency(
&right_oid, &declared, 1, result_type, true);
rtype = PyPgType_FromOid(result_type);
Py_XACQUIRE(rtype);
list_free((List *) namelist);
namelist = NULL;
if (rtype == NULL)
elog(ERROR, "operator result type could not be created");
fmgr_info(fn_oid, &flinfo);
fcinfo.flinfo = &flinfo;
fcinfo.nargs = 1;
fcinfo.arg[0] = dright;
fcinfo.argnull[0] = false;
rd = FunctionCallInvoke(&fcinfo);
if (fcinfo.isnull)
{
rob = Py_None;
Py_INCREF(rob);
Py_ACQUIRE(rob);
}
else
{
rob = PyPgObject_New(rtype, rd);
Py_XACQUIRE(rob);
if (PyPgType_ShouldFree(rtype))
pfree(DatumGetPointer(rd));
}
}
PG_CATCH();
{
PyErr_SetPgError(false);
rob = NULL;
}
PG_END_TRY();
Py_XINCREF(rob);
}
Py_DEALLOCATE_OWNER();
return(rob);
}
/*
* record_cmp()
* Internal comparison function for records.
*
* Returns -1, 0 or 1
*
* Do not assume that the two inputs are exactly the same record type;
* for instance we might be comparing an anonymous ROW() construct against a
* named composite type. We will compare as long as they have the same number
* of non-dropped columns of the same types.
*/
static int
record_cmp(FunctionCallInfo fcinfo)
{
HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
int result = 0;
Oid tupType1;
Oid tupType2;
int32 tupTypmod1;
int32 tupTypmod2;
TupleDesc tupdesc1;
TupleDesc tupdesc2;
HeapTupleData tuple1;
HeapTupleData tuple2;
int ncolumns1;
int ncolumns2;
RecordCompareData *my_extra;
int ncols;
Datum *values1;
Datum *values2;
bool *nulls1;
bool *nulls2;
int i1;
int i2;
int j;
/* Extract type info from the tuples */
tupType1 = HeapTupleHeaderGetTypeId(record1);
tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
ncolumns1 = tupdesc1->natts;
tupType2 = HeapTupleHeaderGetTypeId(record2);
tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
ncolumns2 = tupdesc2->natts;
/* Build temporary HeapTuple control structures */
tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
ItemPointerSetInvalid(&(tuple1.t_self));
tuple1.t_tableOid = InvalidOid;
tuple1.t_data = record1;
tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
ItemPointerSetInvalid(&(tuple2.t_self));
tuple2.t_tableOid = InvalidOid;
tuple2.t_data = record2;
/*
* We arrange to look up the needed comparison info just once per series
* of calls, assuming the record types don't change underneath us.
*/
ncols = Max(ncolumns1, ncolumns2);
my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
if (my_extra == NULL ||
my_extra->ncolumns < ncols)
{
fcinfo->flinfo->fn_extra =
MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
sizeof(RecordCompareData) - sizeof(ColumnCompareData)
+ ncols * sizeof(ColumnCompareData));
my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
my_extra->ncolumns = ncols;
my_extra->record1_type = InvalidOid;
my_extra->record1_typmod = 0;
my_extra->record2_type = InvalidOid;
my_extra->record2_typmod = 0;
}
if (my_extra->record1_type != tupType1 ||
my_extra->record1_typmod != tupTypmod1 ||
my_extra->record2_type != tupType2 ||
my_extra->record2_typmod != tupTypmod2)
{
MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
my_extra->record1_type = tupType1;
my_extra->record1_typmod = tupTypmod1;
my_extra->record2_type = tupType2;
my_extra->record2_typmod = tupTypmod2;
}
/* Break down the tuples into fields */
values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
/*
* Scan corresponding columns, allowing for dropped columns in different
* places in the two rows. i1 and i2 are physical column indexes, j is
* the logical column index.
*/
i1 = i2 = j = 0;
while (i1 < ncolumns1 || i2 < ncolumns2)
{
TypeCacheEntry *typentry;
Oid collation;
FunctionCallInfoData locfcinfo;
int32 cmpresult;
/*
* Skip dropped columns
*/
if (i1 < ncolumns1 && tupdesc1->attrs[i1]->attisdropped)
{
i1++;
continue;
}
if (i2 < ncolumns2 && tupdesc2->attrs[i2]->attisdropped)
{
i2++;
continue;
}
if (i1 >= ncolumns1 || i2 >= ncolumns2)
break; /* we'll deal with mismatch below loop */
/*
* Have two matching columns, they must be same type
*/
if (tupdesc1->attrs[i1]->atttypid !=
tupdesc2->attrs[i2]->atttypid)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("cannot compare dissimilar column types %s and %s at record column %d",
format_type_be(tupdesc1->attrs[i1]->atttypid),
format_type_be(tupdesc2->attrs[i2]->atttypid),
j + 1)));
/*
* If they're not same collation, we don't complain here, but the
* comparison function might.
*/
collation = tupdesc1->attrs[i1]->attcollation;
if (collation != tupdesc2->attrs[i2]->attcollation)
collation = InvalidOid;
/*
* Lookup the comparison function if not done already
*/
typentry = my_extra->columns[j].typentry;
if (typentry == NULL ||
typentry->type_id != tupdesc1->attrs[i1]->atttypid)
{
typentry = lookup_type_cache(tupdesc1->attrs[i1]->atttypid,
TYPECACHE_CMP_PROC_FINFO);
if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
errmsg("could not identify a comparison function for type %s",
format_type_be(typentry->type_id))));
my_extra->columns[j].typentry = typentry;
}
/*
* We consider two NULLs equal; NULL > not-NULL.
*/
if (!nulls1[i1] || !nulls2[i2])
{
if (nulls1[i1])
{
/* arg1 is greater than arg2 */
result = 1;
break;
}
if (nulls2[i2])
{
/* arg1 is less than arg2 */
result = -1;
break;
}
/* Compare the pair of elements */
InitFunctionCallInfoData(locfcinfo, &typentry->cmp_proc_finfo, 2,
collation, NULL, NULL);
locfcinfo.arg[0] = values1[i1];
locfcinfo.arg[1] = values2[i2];
locfcinfo.argnull[0] = false;
locfcinfo.argnull[1] = false;
locfcinfo.isnull = false;
cmpresult = DatumGetInt32(FunctionCallInvoke(&locfcinfo));
if (cmpresult < 0)
{
/* arg1 is less than arg2 */
result = -1;
break;
}
else if (cmpresult > 0)
{
/* arg1 is greater than arg2 */
result = 1;
break;
}
}
/* equal, so continue to next column */
i1++, i2++, j++;
}
/*
* If we didn't break out of the loop early, check for column count
* mismatch. (We do not report such mismatch if we found unequal column
* values; is that a feature or a bug?)
*/
if (result == 0)
{
if (i1 != ncolumns1 || i2 != ncolumns2)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("cannot compare record types with different numbers of columns")));
}
pfree(values1);
pfree(nulls1);
pfree(values2);
pfree(nulls2);
ReleaseTupleDesc(tupdesc1);
ReleaseTupleDesc(tupdesc2);
/* Avoid leaking memory when handed toasted input. */
PG_FREE_IF_COPY(record1, 0);
PG_FREE_IF_COPY(record2, 1);
return result;
}
static PyObj
binary_operate(const char *op, PyObj left, PyObj right)
{
PyObj base = PyPgObject_Check(left) ? left : right;
PyObj rob = NULL;
Datum dleft, dright;
Datum dcoerce;
bool lisnull = false, risnull = false, coerce_isnull = true;
Oid left_oid, right_oid;
Py_ALLOCATE_OWNER();
{
volatile Datum rd = 0;
List * volatile namelist = NULL;
PyObj rtype;
PyObj coerce = NULL;
PG_TRY();
{
struct FmgrInfo flinfo = {0,};
struct FunctionCallInfoData fcinfo = {0,};
Operator opt;
Form_pg_operator ops;
Oid actual[2];
Oid declared[2];
Oid result_type, fn_oid;
/*
* base and coerce are used to manage preliminary coercion.
* If either side of the operator is not a PyPgObject, convert the
* object to the type of the other side.
*/
if (base == left)
{
if (!PyPgObject_Check(right))
coerce = right;
}
else
coerce = left;
if (coerce != NULL)
{
PyPgType_DatumNew((PyObj) Py_TYPE(base),
coerce, -1, &dcoerce, &coerce_isnull);
if (base == left)
{
dleft = PyPgObject_GetDatum(left);
lisnull = false;
dright = dcoerce;
risnull = coerce_isnull;
}
else
{
dleft = dcoerce;
lisnull = coerce_isnull;
dright = PyPgObject_GetDatum(right);
risnull = false;
}
/*
* Both are the same type as base due to coercion.
*/
left_oid = right_oid = PyPgType_GetOid(Py_TYPE(base));
}
else
{
/*
* Both objects are PyPgObjects.
*/
dleft = PyPgObject_GetDatum(left);
left_oid = PyPgType_GetOid(Py_TYPE(left));
dright = PyPgObject_GetDatum(right);
right_oid = PyPgType_GetOid(Py_TYPE(right));
}
namelist = stringToQualifiedNameList(op);
opt = oper(NULL, (List *) namelist, left_oid, right_oid, false, 1);
ops = (Form_pg_operator) GETSTRUCT(opt);
fn_oid = ops->oprcode;
declared[0] = ops->oprleft;
declared[1] = ops->oprright;
actual[0] = left_oid;
actual[1] = right_oid;
result_type = ops->oprresult;
ReleaseSysCache((HeapTuple) opt);
result_type = enforce_generic_type_consistency(
actual, declared, 2, result_type, true);
rtype = PyPgType_FromOid(result_type);
rtype = Py_XACQUIRE(rtype);
list_free((List *) namelist);
namelist = NULL;
if (rtype == NULL)
PyErr_RelayException();
fmgr_info(fn_oid, &flinfo);
fcinfo.flinfo = &flinfo;
fcinfo.nargs = 2;
fcinfo.arg[0] = dleft;
fcinfo.argnull[0] = lisnull;
fcinfo.arg[1] = dright;
fcinfo.argnull[1] = risnull;
rd = FunctionCallInvoke(&fcinfo);
if (fcinfo.isnull)
rob = Py_None;
else
{
rob = PyPgObject_New(rtype, rd);
Py_XACQUIRE(rob);
if (PyPgType_ShouldFree(rtype))
pfree(DatumGetPointer(rd));
}
if (!coerce_isnull && PyPgType_ShouldFree(Py_TYPE(base)))
pfree(DatumGetPointer(dcoerce));
}
PG_CATCH();
{
PyErr_SetPgError(false);
rob = NULL;
}
PG_END_TRY();
Py_XINCREF(rob);
}
Py_DEALLOCATE_OWNER();
return(rob);
}
static PyObj
func_call(PyObj self, PyObj args, PyObj kw)
{
MemoryContext former = CurrentMemoryContext;
PyObj fn_input, fn_output, input, rob = NULL;
TupleDesc td;
FmgrInfo flinfo;
FunctionCallInfoData fcinfo;
volatile Datum datum = 0;
/*
* Disallow execution of "anonymous" functions.
*/
flinfo.fn_addr = PyPgFunction_GetPGFunction(self);
flinfo.fn_oid = PyPgFunction_GetOid(self);
flinfo.fn_retset = PyPgFunction_GetReturnsSet(self);
if (flinfo.fn_addr == NULL || flinfo.fn_oid == InvalidOid)
{
PyErr_SetString(PyExc_TypeError, "internal functions are not directly callable");
return(NULL);
}
if (flinfo.fn_retset)
{
PyErr_SetString(PyExc_NotImplementedError,
"cannot directly execute set returning functions");
return(NULL);
}
fn_input = PyPgFunction_GetInput(self);
fn_output = PyPgFunction_GetOutput(self);
if (PyPgTupleDesc_IsPolymorphic(fn_input) ||
PyPgType_IsPolymorphic(fn_output))
{
PyErr_SetString(PyExc_NotImplementedError,
"cannot directly execute polymorphic functions");
return(NULL);
}
if (PyPgType_GetOid(fn_output) == TRIGGEROID)
{
PyErr_SetString(PyExc_NotImplementedError,
"cannot directly execute TRIGGER returning functions");
return(NULL);
}
/* No access if failed transaction */
if (DB_IS_NOT_READY())
return(NULL);
td = PyPgTupleDesc_GetTupleDesc(fn_input);
/*
* Normalize the parameters.
*/
input = PyTuple_FromTupleDescAndParameters(td, args, kw);
if (input == NULL)
return(NULL);
flinfo.fn_nargs = td->natts;
flinfo.fn_extra = NULL;
flinfo.fn_mcxt = CurrentMemoryContext;
flinfo.fn_expr = NULL;
fcinfo.flinfo = &flinfo;
fcinfo.context = NULL;
fcinfo.resultinfo = NULL;
fcinfo.isnull = false;
/*
* Custom built descriptor; no dropped attributes.
*/
fcinfo.nargs = td->natts;
SPI_push();
PG_TRY();
{
Py_BuildDatumsAndNulls(td,
PyPgTupleDesc_GetTypesTuple(fn_input),
input, fcinfo.arg, fcinfo.argnull);
datum = FunctionCallInvoke(&fcinfo);
/*
* Special casing void to avoid the singleton.
*/
if (fcinfo.isnull ||
PyPgType_GetOid(fn_output) == VOIDOID)
{
rob = Py_None;
Py_INCREF(rob);
}
else
{
/*
* Some functions will return a parameter that its given.
* This is problematic if we are going to free the output
* after re-allocating as a Postgres.Object.
*/
if (PyPgType_ShouldFree(fn_output))
{
int i;
/*
* Scan for !typbyval parameters.
* When one is found, compare the datum to the result datum.
*/
for (i = 0; i < PyTuple_GET_SIZE(input); ++i)
{
PyObj param = PyTuple_GET_ITEM(input, i);
/*
* It's tempting to check the types first, but in situations
* of functions doing binary compatible coercion, it would be a
* mistake.
*/
if (PyPgType_ShouldFree(Py_TYPE(param)))
{
if (PyPgObject_GetDatum(param) == datum)
{
/*
* It's the same Datum of an argument,
* inc the ref and return the param.
*/
if (fn_output == (PyObj) Py_TYPE(param))
{
rob = param;
Py_INCREF(rob);
}
else
{
/*
* It's the same Datum, but a different type.
* Make a Copy.
*/
rob = PyPgObject_New(fn_output, datum);
}
break;
}
}
}
/*
* It's a newly allocated result? (not an argument)
*/
if (rob == NULL)
{
/*
* New result, Datum is copied into the PythonMemoryContext
*/
rob = PyPgObject_New(fn_output, datum);
/*
* Cleanup.
*/
pfree(DatumGetPointer(datum));
}
}
else
{
/* Not pfree'ing typbyval, so no need to check parameters. */
rob = PyPgObject_New(fn_output, datum);
}
}
}
PG_CATCH();
{
Py_XDECREF(rob);
rob = NULL;
PyErr_SetPgError(false);
}
PG_END_TRY();
SPI_pop();
Py_DECREF(input);
MemoryContextSwitchTo(former);
return(rob);
}
/*
* ExecMakeFunctionResultSet
*
* Evaluate the arguments to a set-returning function and then call the
* function itself. The argument expressions may not contain set-returning
* functions (the planner is supposed to have separated evaluation for those).
*
* This should be called in a short-lived (per-tuple) context, argContext
* needs to live until all rows have been returned (i.e. *isDone set to
* ExprEndResult or ExprSingleResult).
*
* This is used by nodeProjectSet.c.
*/
Datum
ExecMakeFunctionResultSet(SetExprState *fcache,
ExprContext *econtext,
MemoryContext argContext,
bool *isNull,
ExprDoneCond *isDone)
{
List *arguments;
Datum result;
FunctionCallInfo fcinfo;
PgStat_FunctionCallUsage fcusage;
ReturnSetInfo rsinfo;
bool callit;
int i;
restart:
/* Guard against stack overflow due to overly complex expressions */
check_stack_depth();
/*
* If a previous call of the function returned a set result in the form of
* a tuplestore, continue reading rows from the tuplestore until it's
* empty.
*/
if (fcache->funcResultStore)
{
TupleTableSlot *slot = fcache->funcResultSlot;
MemoryContext oldContext;
bool foundTup;
/*
* Have to make sure tuple in slot lives long enough, otherwise
* clearing the slot could end up trying to free something already
* freed.
*/
oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
foundTup = tuplestore_gettupleslot(fcache->funcResultStore, true, false,
fcache->funcResultSlot);
MemoryContextSwitchTo(oldContext);
if (foundTup)
{
*isDone = ExprMultipleResult;
if (fcache->funcReturnsTuple)
{
/* We must return the whole tuple as a Datum. */
*isNull = false;
return ExecFetchSlotTupleDatum(fcache->funcResultSlot);
}
else
{
/* Extract the first column and return it as a scalar. */
return slot_getattr(fcache->funcResultSlot, 1, isNull);
}
}
/* Exhausted the tuplestore, so clean up */
tuplestore_end(fcache->funcResultStore);
fcache->funcResultStore = NULL;
*isDone = ExprEndResult;
*isNull = true;
return (Datum) 0;
}
/*
* arguments is a list of expressions to evaluate before passing to the
* function manager. We skip the evaluation if it was already done in the
* previous call (ie, we are continuing the evaluation of a set-valued
* function). Otherwise, collect the current argument values into fcinfo.
*
* The arguments have to live in a context that lives at least until all
* rows from this SRF have been returned, otherwise ValuePerCall SRFs
* would reference freed memory after the first returned row.
*/
fcinfo = &fcache->fcinfo_data;
arguments = fcache->args;
if (!fcache->setArgsValid)
{
MemoryContext oldContext = MemoryContextSwitchTo(argContext);
ExecEvalFuncArgs(fcinfo, arguments, econtext);
MemoryContextSwitchTo(oldContext);
}
else
{
/* Reset flag (we may set it again below) */
fcache->setArgsValid = false;
}
/*
* Now call the function, passing the evaluated parameter values.
*/
/* Prepare a resultinfo node for communication. */
fcinfo->resultinfo = (Node *) &rsinfo;
rsinfo.type = T_ReturnSetInfo;
rsinfo.econtext = econtext;
rsinfo.expectedDesc = fcache->funcResultDesc;
rsinfo.allowedModes = (int) (SFRM_ValuePerCall | SFRM_Materialize);
/* note we do not set SFRM_Materialize_Random or _Preferred */
rsinfo.returnMode = SFRM_ValuePerCall;
/* isDone is filled below */
rsinfo.setResult = NULL;
rsinfo.setDesc = NULL;
/*
* If function is strict, and there are any NULL arguments, skip calling
* the function.
*/
callit = true;
if (fcache->func.fn_strict)
{
for (i = 0; i < fcinfo->nargs; i++)
{
if (fcinfo->argnull[i])
{
callit = false;
break;
}
}
}
if (callit)
{
pgstat_init_function_usage(fcinfo, &fcusage);
fcinfo->isnull = false;
rsinfo.isDone = ExprSingleResult;
result = FunctionCallInvoke(fcinfo);
*isNull = fcinfo->isnull;
*isDone = rsinfo.isDone;
pgstat_end_function_usage(&fcusage,
rsinfo.isDone != ExprMultipleResult);
}
else
{
/* for a strict SRF, result for NULL is an empty set */
result = (Datum) 0;
*isNull = true;
*isDone = ExprEndResult;
}
/* Which protocol does function want to use? */
if (rsinfo.returnMode == SFRM_ValuePerCall)
{
if (*isDone != ExprEndResult)
{
/*
* Save the current argument values to re-use on the next call.
*/
if (*isDone == ExprMultipleResult)
{
fcache->setArgsValid = true;
/* Register cleanup callback if we didn't already */
if (!fcache->shutdown_reg)
{
RegisterExprContextCallback(econtext,
ShutdownSetExpr,
PointerGetDatum(fcache));
fcache->shutdown_reg = true;
}
}
}
}
else if (rsinfo.returnMode == SFRM_Materialize)
{
/* check we're on the same page as the function author */
if (rsinfo.isDone != ExprSingleResult)
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
errmsg("table-function protocol for materialize mode was not followed")));
if (rsinfo.setResult != NULL)
{
/* prepare to return values from the tuplestore */
ExecPrepareTuplestoreResult(fcache, econtext,
rsinfo.setResult,
rsinfo.setDesc);
/* loop back to top to start returning from tuplestore */
goto restart;
}
/* if setResult was left null, treat it as empty set */
*isDone = ExprEndResult;
*isNull = true;
result = (Datum) 0;
}
else
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
errmsg("unrecognized table-function returnMode: %d",
(int) rsinfo.returnMode)));
return result;
}
/*
* ExecMakeTableFunctionResult
*
* Evaluate a table function, producing a materialized result in a Tuplestore
* object.
*
* This is used by nodeFunctionscan.c.
*/
Tuplestorestate *
ExecMakeTableFunctionResult(SetExprState *setexpr,
ExprContext *econtext,
MemoryContext argContext,
TupleDesc expectedDesc,
bool randomAccess)
{
Tuplestorestate *tupstore = NULL;
TupleDesc tupdesc = NULL;
Oid funcrettype;
bool returnsTuple;
bool returnsSet = false;
FunctionCallInfoData fcinfo;
PgStat_FunctionCallUsage fcusage;
ReturnSetInfo rsinfo;
HeapTupleData tmptup;
MemoryContext callerContext;
MemoryContext oldcontext;
bool first_time = true;
callerContext = CurrentMemoryContext;
funcrettype = exprType((Node *) setexpr->expr);
returnsTuple = type_is_rowtype(funcrettype);
/*
* Prepare a resultinfo node for communication. We always do this even if
* not expecting a set result, so that we can pass expectedDesc. In the
* generic-expression case, the expression doesn't actually get to see the
* resultinfo, but set it up anyway because we use some of the fields as
* our own state variables.
*/
rsinfo.type = T_ReturnSetInfo;
rsinfo.econtext = econtext;
rsinfo.expectedDesc = expectedDesc;
rsinfo.allowedModes = (int) (SFRM_ValuePerCall | SFRM_Materialize | SFRM_Materialize_Preferred);
if (randomAccess)
rsinfo.allowedModes |= (int) SFRM_Materialize_Random;
rsinfo.returnMode = SFRM_ValuePerCall;
/* isDone is filled below */
rsinfo.setResult = NULL;
rsinfo.setDesc = NULL;
/*
* Normally the passed expression tree will be a SetExprState, since the
* grammar only allows a function call at the top level of a table
* function reference. However, if the function doesn't return set then
* the planner might have replaced the function call via constant-folding
* or inlining. So if we see any other kind of expression node, execute
* it via the general ExecEvalExpr() code; the only difference is that we
* don't get a chance to pass a special ReturnSetInfo to any functions
* buried in the expression.
*/
if (!setexpr->elidedFuncState)
{
/*
* This path is similar to ExecMakeFunctionResultSet.
*/
returnsSet = setexpr->funcReturnsSet;
InitFunctionCallInfoData(fcinfo, &(setexpr->func),
list_length(setexpr->args),
setexpr->fcinfo_data.fncollation,
NULL, (Node *) &rsinfo);
/*
* Evaluate the function's argument list.
*
* We can't do this in the per-tuple context: the argument values
* would disappear when we reset that context in the inner loop. And
* the caller's CurrentMemoryContext is typically a query-lifespan
* context, so we don't want to leak memory there. We require the
* caller to pass a separate memory context that can be used for this,
* and can be reset each time through to avoid bloat.
*/
MemoryContextReset(argContext);
oldcontext = MemoryContextSwitchTo(argContext);
ExecEvalFuncArgs(&fcinfo, setexpr->args, econtext);
MemoryContextSwitchTo(oldcontext);
/*
* If function is strict, and there are any NULL arguments, skip
* calling the function and act like it returned NULL (or an empty
* set, in the returns-set case).
*/
if (setexpr->func.fn_strict)
{
int i;
for (i = 0; i < fcinfo.nargs; i++)
{
if (fcinfo.argnull[i])
goto no_function_result;
}
}
}
else
{
/* Treat setexpr as a generic expression */
InitFunctionCallInfoData(fcinfo, NULL, 0, InvalidOid, NULL, NULL);
}
/*
* Switch to short-lived context for calling the function or expression.
*/
MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
/*
* Loop to handle the ValuePerCall protocol (which is also the same
* behavior needed in the generic ExecEvalExpr path).
*/
for (;;)
{
Datum result;
CHECK_FOR_INTERRUPTS();
/*
* reset per-tuple memory context before each call of the function or
* expression. This cleans up any local memory the function may leak
* when called.
*/
ResetExprContext(econtext);
/* Call the function or expression one time */
if (!setexpr->elidedFuncState)
{
pgstat_init_function_usage(&fcinfo, &fcusage);
fcinfo.isnull = false;
rsinfo.isDone = ExprSingleResult;
result = FunctionCallInvoke(&fcinfo);
pgstat_end_function_usage(&fcusage,
rsinfo.isDone != ExprMultipleResult);
}
else
{
result =
ExecEvalExpr(setexpr->elidedFuncState, econtext, &fcinfo.isnull);
rsinfo.isDone = ExprSingleResult;
}
/* Which protocol does function want to use? */
if (rsinfo.returnMode == SFRM_ValuePerCall)
{
/*
* Check for end of result set.
*/
if (rsinfo.isDone == ExprEndResult)
break;
/*
* If first time through, build tuplestore for result. For a
* scalar function result type, also make a suitable tupdesc.
*/
if (first_time)
{
oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
rsinfo.setResult = tupstore;
if (!returnsTuple)
{
tupdesc = CreateTemplateTupleDesc(1, false);
TupleDescInitEntry(tupdesc,
(AttrNumber) 1,
"column",
funcrettype,
-1,
0);
rsinfo.setDesc = tupdesc;
}
MemoryContextSwitchTo(oldcontext);
}
/*
* Store current resultset item.
*/
if (returnsTuple)
{
if (!fcinfo.isnull)
{
HeapTupleHeader td = DatumGetHeapTupleHeader(result);
if (tupdesc == NULL)
{
/*
* This is the first non-NULL result from the
* function. Use the type info embedded in the
* rowtype Datum to look up the needed tupdesc. Make
* a copy for the query.
*/
oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
tupdesc = lookup_rowtype_tupdesc_copy(HeapTupleHeaderGetTypeId(td),
HeapTupleHeaderGetTypMod(td));
rsinfo.setDesc = tupdesc;
MemoryContextSwitchTo(oldcontext);
}
else
{
/*
* Verify all later returned rows have same subtype;
* necessary in case the type is RECORD.
*/
if (HeapTupleHeaderGetTypeId(td) != tupdesc->tdtypeid ||
HeapTupleHeaderGetTypMod(td) != tupdesc->tdtypmod)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("rows returned by function are not all of the same row type")));
}
/*
* tuplestore_puttuple needs a HeapTuple not a bare
* HeapTupleHeader, but it doesn't need all the fields.
*/
tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
tmptup.t_data = td;
tuplestore_puttuple(tupstore, &tmptup);
}
else
{
/*
* NULL result from a tuple-returning function; expand it
* to a row of all nulls. We rely on the expectedDesc to
* form such rows. (Note: this would be problematic if
* tuplestore_putvalues saved the tdtypeid/tdtypmod from
* the provided descriptor, since that might not match
* what we get from the function itself. But it doesn't.)
*/
int natts = expectedDesc->natts;
bool *nullflags;
nullflags = (bool *) palloc(natts * sizeof(bool));
memset(nullflags, true, natts * sizeof(bool));
tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
}
}
else
{
/* Scalar-type case: just store the function result */
tuplestore_putvalues(tupstore, tupdesc, &result, &fcinfo.isnull);
}
/*
* Are we done?
*/
if (rsinfo.isDone != ExprMultipleResult)
break;
}
else if (rsinfo.returnMode == SFRM_Materialize)
{
/* check we're on the same page as the function author */
if (!first_time || rsinfo.isDone != ExprSingleResult)
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
errmsg("table-function protocol for materialize mode was not followed")));
/* Done evaluating the set result */
break;
}
else
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
errmsg("unrecognized table-function returnMode: %d",
(int) rsinfo.returnMode)));
first_time = false;
}
no_function_result:
/*
* If we got nothing from the function (ie, an empty-set or NULL result),
* we have to create the tuplestore to return, and if it's a
* non-set-returning function then insert a single all-nulls row. As
* above, we depend on the expectedDesc to manufacture the dummy row.
*/
if (rsinfo.setResult == NULL)
{
MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
rsinfo.setResult = tupstore;
if (!returnsSet)
{
int natts = expectedDesc->natts;
bool *nullflags;
MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
nullflags = (bool *) palloc(natts * sizeof(bool));
memset(nullflags, true, natts * sizeof(bool));
tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
}
}
/*
* If function provided a tupdesc, cross-check it. We only really need to
* do this for functions returning RECORD, but might as well do it always.
*/
if (rsinfo.setDesc)
{
tupledesc_match(expectedDesc, rsinfo.setDesc);
/*
* If it is a dynamically-allocated TupleDesc, free it: it is
* typically allocated in a per-query context, so we must avoid
* leaking it across multiple usages.
*/
if (rsinfo.setDesc->tdrefcount == -1)
FreeTupleDesc(rsinfo.setDesc);
}
MemoryContextSwitchTo(callerContext);
/* All done, pass back the tuplestore */
return rsinfo.setResult;
}
/*
* decode(lhs, [rhs, ret], ..., [default])
*/
Datum
ora_decode(PG_FUNCTION_ARGS)
{
int nargs;
int i;
int retarg;
/* default value is last arg or NULL. */
nargs = PG_NARGS();
if (nargs % 2 == 0)
{
retarg = nargs - 1;
nargs -= 1; /* ignore the last argument */
}
else
retarg = -1; /* NULL */
if (PG_ARGISNULL(0))
{
for (i = 1; i < nargs; i += 2)
{
if (PG_ARGISNULL(i))
{
retarg = i + 1;
break;
}
}
}
else
{
FmgrInfo *eq;
#if PG_VERSION_NUM >= 90100
Oid collation = PG_GET_COLLATION();
#endif
/*
* On first call, get the input type's operator '=' and save at
* fn_extra.
*/
if (fcinfo->flinfo->fn_extra == NULL)
{
MemoryContext oldctx;
Oid typid = get_fn_expr_argtype(fcinfo->flinfo, 0);
Oid eqoid = equality_oper_funcid(typid);
oldctx = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
eq = palloc(sizeof(FmgrInfo));
fmgr_info(eqoid, eq);
MemoryContextSwitchTo(oldctx);
fcinfo->flinfo->fn_extra = eq;
}
else
eq = fcinfo->flinfo->fn_extra;
for (i = 1; i < nargs; i += 2)
{
FunctionCallInfoData func;
Datum result;
if (PG_ARGISNULL(i))
continue;
#if PG_VERSION_NUM >= 90100
InitFunctionCallInfoData(func, eq, 2, collation, NULL, NULL);
#else
InitFunctionCallInfoData(func, eq, 2, NULL, NULL);
#endif
func.arg[0] = PG_GETARG_DATUM(0);
func.arg[1] = PG_GETARG_DATUM(i);
func.argnull[0] = false;
func.argnull[1] = false;
result = FunctionCallInvoke(&func);
if (!func.isnull && DatumGetBool(result))
{
retarg = i + 1;
break;
}
}
}
if (retarg < 0 || PG_ARGISNULL(retarg))
PG_RETURN_NULL();
else
PG_RETURN_DATUM(PG_GETARG_DATUM(retarg));
}
