#include "postgres.h"

#include "fmgr.h"

#include "funcapi.h"

#include "access/tupconvert.h"

#include "catalog/pg_type_d.h"

#include "catalog/pg_type.h"

#include "executor/spi.h"

#include "lib/stringinfo.h"

#include "parser/parse_coerce.h"

#include "parser/scansup.h"

#include "utils/array.h"

#include "utils/builtins.h"

#include "utils/datum.h"

#include "utils/elog.h"

#include "utils/lsyscache.h"

#include "utils/syscache.h"

#include "utils/memutils.h"

#include "utils/typcache.h"

#include "executor/spi_priv.h"

#include "orafce.h"

#include "builtins.h"

#define MAX_CURSORS 100

/*

* bind variable data

*/

typedef struct

{

char *refname;

int position;

Datum value;

Oid typoid;

bool typbyval;

int16 typlen;

bool isnull;

unsigned int varno; /* number of assigned placeholder of parsed

* query */

bool is_array; /* true, when a value is assigned via

* bind_array */

Oid typelemid; /* Oid of element of a array */

bool typelembyval;

int16 typelemlen;

int index1;

int index2;

} VariableData;

/*

* Query result column definition

*/

typedef struct

{

int position;

Oid typoid;

bool typbyval;

int16 typlen;

int32 typmod;

bool typisstr;

Oid typarrayoid; /* oid of requested array output value */

uint64 rowcount; /* maximal rows of requested array */

int index1; /* output array should be rewrited from this

* index */

} ColumnData;

/*

* It is used for transformation result data to form

* generated by column_value procedure or column

* value function.

*/

typedef struct

{

bool isvalid; /* true, when this cast can be used */

bool without_cast; /* true, when cast is not necessary */

Oid targettypid; /* used for domains */

Oid array_targettypid; /* used for array domains */

int32 targettypmod; /* used for strings */

bool typbyval; /* used for copy result to outer memory

* context */

int16 typlen; /* used for copy result to outer memory

* context */

bool is_array;

Oid funcoid;

Oid funcoid_typmod;

CoercionPathType path;

CoercionPathType path_typmod;

FmgrInfo finfo;

FmgrInfo finfo_typmod;

FmgrInfo finfo_out;

FmgrInfo finfo_in;

Oid typIOParam;

} CastCacheData;

/*

* dbms_sql cursor definition

*/

typedef struct

{

int16 cid;

char *parsed_query;

char *original_query;

unsigned int nvariables;

int max_colpos;

List *variables;

List *columns;

char cursorname[32];

Portal portal; /* one shot (execute) plan */

SPIPlanPtr plan;

MemoryContext cursor_cxt;

MemoryContext cursor_xact_cxt;

MemoryContext tuples_cxt;

MemoryContext result_cxt; /* short life memory context */

HeapTuple tuples[1000];

TupleDesc coltupdesc;

TupleDesc tupdesc;

CastCacheData *casts;

uint64 processed;

uint64 nread;

uint64 start_read;

bool assigned;

bool executed;

Bitmapset *array_columns; /* set of array columns */

uint64 batch_rows; /* how much rows should be fetched to fill

* target arrays */

} CursorData;

typedef enum

{

TOKEN_SPACES,

TOKEN_COMMENT,

TOKEN_NUMBER,

TOKEN_BIND_VAR,

TOKEN_STR,

TOKEN_EXT_STR,

TOKEN_DOLAR_STR,

TOKEN_IDENTIF,

TOKEN_QIDENTIF,

TOKEN_DOUBLE_COLON,

TOKEN_OTHER,

TOKEN_NONE

} orafceTokenType;

static char *next_token(char *str, char **start, size_t *len, orafceTokenType *typ, char **sep, size_t *seplen);

PG_FUNCTION_INFO_V1(dbms_sql_is_open);

PG_FUNCTION_INFO_V1(dbms_sql_open_cursor);

PG_FUNCTION_INFO_V1(dbms_sql_close_cursor);

PG_FUNCTION_INFO_V1(dbms_sql_parse);

PG_FUNCTION_INFO_V1(dbms_sql_bind_variable);

PG_FUNCTION_INFO_V1(dbms_sql_bind_variable_f);

PG_FUNCTION_INFO_V1(dbms_sql_bind_array_3);

PG_FUNCTION_INFO_V1(dbms_sql_bind_array_5);

PG_FUNCTION_INFO_V1(dbms_sql_define_column);

PG_FUNCTION_INFO_V1(dbms_sql_define_array);

PG_FUNCTION_INFO_V1(dbms_sql_execute);

PG_FUNCTION_INFO_V1(dbms_sql_fetch_rows);

PG_FUNCTION_INFO_V1(dbms_sql_execute_and_fetch);

PG_FUNCTION_INFO_V1(dbms_sql_column_value);

PG_FUNCTION_INFO_V1(dbms_sql_column_value_f);

PG_FUNCTION_INFO_V1(dbms_sql_last_row_count);

PG_FUNCTION_INFO_V1(dbms_sql_describe_columns);

PG_FUNCTION_INFO_V1(dbms_sql_describe_columns_f);

PG_FUNCTION_INFO_V1(dbms_sql_debug_cursor);

static uint64 last_row_count = 0;

static MemoryContext persist_cxt = NULL;

static CursorData cursors[MAX_CURSORS];

static void

open_cursor(CursorData *c, int cid)

{

c->cid = cid;

if (!persist_cxt)

{

persist_cxt = AllocSetContextCreate(NULL,

"dbms_sql persist context",

ALLOCSET_DEFAULT_SIZES);

memset(cursors, 0, sizeof(cursors));

}

c->cursor_cxt = AllocSetContextCreate(persist_cxt,

"dbms_sql cursor context",

ALLOCSET_DEFAULT_SIZES);

c->assigned = true;

}

/*

* FUNCTION dbms_sql.open_cursor() RETURNS int

*/

Datum

dbms_sql_open_cursor(PG_FUNCTION_ARGS)

{

int i;

(void) fcinfo;

/* find and initialize first free slot */

for (i = 0; i < MAX_CURSORS; i++)

{

if (!cursors[i].assigned)

{

open_cursor(&cursors[i], i);

PG_RETURN_INT32(i);

}

}

ereport(ERROR,

(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

errmsg("too many opened cursors"),

errdetail("There is not free slot for new dbms_sql's cursor."),

errhint("You should to close unused cursors")));

/* be msvc quiet */

return (Datum) 0;

}

static CursorData *

get_cursor(FunctionCallInfo fcinfo, bool should_be_assigned)

{

CursorData *cursor;

int cid;

if (PG_ARGISNULL(0))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("cursor id is NULL")));

cid = PG_GETARG_INT32(0);

if (cid < 0 || cid >= MAX_CURSORS)

ereport(ERROR,

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("value of cursor id is out of range")));

cursor = &cursors[cid];

if (!cursor->assigned && should_be_assigned)

ereport(ERROR,

(errcode(ERRCODE_UNDEFINED_CURSOR),

errmsg("cursor is not valid")));

return cursor;

}

/*

* CREATE FUNCTION dbms_sql.is_open(c int) RETURNS bool;

*/

Datum

dbms_sql_is_open(PG_FUNCTION_ARGS)

{

CursorData *c;

c = get_cursor(fcinfo, false);

PG_RETURN_BOOL(c->assigned);

}

/*

* Release all sources assigned to cursor

*/

static void

close_cursor(CursorData *c)

{

if (c->executed && c->portal)

SPI_cursor_close(c->portal);

/* release all assigned memory */

if (c->cursor_cxt)

MemoryContextDelete(c->cursor_cxt);

if (c->cursor_xact_cxt)

MemoryContextDelete(c->cursor_xact_cxt);

if (c->plan)

SPI_freeplan(c->plan);

memset(c, 0, sizeof(CursorData));

}

/*

* PROCEDURE dbms_sql.close_cursor(c int)

*/

Datum

dbms_sql_close_cursor(PG_FUNCTION_ARGS)

{

CursorData *c;

c = get_cursor(fcinfo, false);

close_cursor(c);

return (Datum) 0;

}

/*

* Print state of cursor - just for debug purposes

*/

Datum

dbms_sql_debug_cursor(PG_FUNCTION_ARGS)

{

CursorData *c;

ListCell *lc;

c = get_cursor(fcinfo, false);

if (c->assigned)

{

if (c->original_query)

elog(NOTICE, "orig query: \"%s\"", c->original_query);

if (c->parsed_query)

elog(NOTICE, "parsed query: \"%s\"", c->parsed_query);

}

else

elog(NOTICE, "cursor is not assigned");

foreach(lc, c->variables)

{

VariableData *var = (VariableData *) lfirst(lc);

if (var->typoid != InvalidOid)

{

if (!var->isnull)

{

Oid typOutput;

bool isVarlena;

char *str;

getTypeOutputInfo(var->typoid, &typOutput, &isVarlena);

str = OidOutputFunctionCall(typOutput, var->value);

elog(NOTICE, "variable \"%s\" is assigned to \"%s\"", var->refname, str);

}

else

elog(NOTICE, "variable \"%s\" is NULL", var->refname);

}

else

elog(NOTICE, "variable \"%s\" is not assigned", var->refname);

}

foreach(lc, c->columns)

{

ColumnData *col = (ColumnData *) lfirst(lc);

elog(NOTICE, "column definition for position %d is %s",

col->position,

format_type_with_typemod(col->typoid, col->typmod));

}

return (Datum) 0;

}

/*

* Search a variable in cursor's variable list

*/

static VariableData *

get_var(CursorData *c, char *refname, int position, bool append)

{

ListCell *lc;

foreach(lc, c->variables)

{

VariableData *var = (VariableData *) lfirst(lc);

if (strcmp(var->refname, refname) == 0)

return var;

}

if (append)

{

VariableData *nvar;

MemoryContext oldcxt;

oldcxt = MemoryContextSwitchTo(c->cursor_cxt);

nvar = palloc0(sizeof(VariableData));

nvar->refname = pstrdup(refname);

nvar->varno = c->nvariables + 1;

nvar->position = position;

c->variables = lappend(c->variables, nvar);

c->nvariables += 1;

MemoryContextSwitchTo(oldcxt);

return nvar;

}

else

ereport(ERROR,

(errcode(ERRCODE_UNDEFINED_PARAMETER),

errmsg("variable \"%s\" doesn't exists", refname)));

/* be msvc quite */

return NULL;

}

/*

* PROCEDURE dbms_sql.parse(c int, stmt varchar)

*/

Datum

dbms_sql_parse(PG_FUNCTION_ARGS)

{

char *query,

*ptr;

char *start;

size_t len;

orafceTokenType typ;

StringInfoData sinfo;

CursorData *c;

MemoryContext oldcxt;

c = get_cursor(fcinfo, true);

if (PG_ARGISNULL(1))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("parsed query string is NULL")));

if (c->parsed_query)

{

int cid = c->cid;

close_cursor(c);

open_cursor(c, cid);

}

query = text_to_cstring(PG_GETARG_TEXT_P(1));

ptr = query;

initStringInfo(&sinfo);

while (ptr)

{

char *startsep;

char *next_ptr;

size_t seplen;

next_ptr = next_token(ptr, &start, &len, &typ, &startsep, &seplen);

if (next_ptr)

{

if (typ == TOKEN_DOLAR_STR)

{

appendStringInfo(&sinfo, "%.*s", (int) seplen, startsep);

appendStringInfo(&sinfo, "%.*s", (int) len, start);

appendStringInfo(&sinfo, "%.*s", (int) seplen, startsep);

}

else if (typ == TOKEN_BIND_VAR)

{

char *name = downcase_identifier(start, (int) len, false, true);

VariableData *var = get_var(c, name, (int) (ptr - query), true);

appendStringInfo(&sinfo, "$%d", var->varno);

pfree(name);

}

else if (typ == TOKEN_EXT_STR)

{

appendStringInfo(&sinfo, "e\'%.*s\'", (int) len, start);

}

else if (typ == TOKEN_STR)

{

appendStringInfo(&sinfo, "\'%.*s\'", (int) len, start);

}

else if (typ == TOKEN_QIDENTIF)

{

appendStringInfo(&sinfo, "\"%.*s\"", (int) len, start);

}

else if (typ != TOKEN_NONE)

{

appendStringInfo(&sinfo, "%.*s", (int) len, start);

}

}

ptr = next_ptr;

}

/* save result to persist context */

oldcxt = MemoryContextSwitchTo(c->cursor_cxt);

c->original_query = pstrdup(query);

c->parsed_query = pstrdup(sinfo.data);

MemoryContextSwitchTo(oldcxt);

pfree(query);

pfree(sinfo.data);

return (Datum) 0;

}

/*

* Calling procedure can be slow, so there is a function alternative

*/

static Datum

bind_variable(PG_FUNCTION_ARGS)

{

CursorData *c;

VariableData *var;

char *varname,

*varname_downcase;

Oid valtype;

bool is_unknown = false;

c = get_cursor(fcinfo, true);

if (PG_ARGISNULL(1))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("name of bind variable is NULL")));

varname = text_to_cstring(PG_GETARG_TEXT_P(1));

if (*varname == ':')

varname += 1;

varname_downcase = downcase_identifier(varname, (int) strlen(varname), false, true);

var = get_var(c, varname_downcase, -1, false);

valtype = get_fn_expr_argtype(fcinfo->flinfo, 2);

if (valtype == RECORDOID)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("cannot to bind a value of record type")));

valtype = getBaseType(valtype);

if (valtype == UNKNOWNOID)

{

is_unknown = true;

valtype = TEXTOID;

}

if (var->typoid != InvalidOid)

{

if (!var->typbyval && !var->isnull)

{

pfree(DatumGetPointer(var->value));

var->value = (Datum) 0;

}

var->isnull = true;

}

var->typoid = valtype;

if (!PG_ARGISNULL(2))

{

MemoryContext oldcxt;

get_typlenbyval(var->typoid, &var->typlen, &var->typbyval);

oldcxt = MemoryContextSwitchTo(c->cursor_cxt);

if (is_unknown)

var->value = CStringGetTextDatum(DatumGetPointer(PG_GETARG_DATUM(2)));

else

var->value = datumCopy(PG_GETARG_DATUM(2), var->typbyval, var->typlen);

var->isnull = false;

MemoryContextSwitchTo(oldcxt);

}

else

var->isnull = true;

return (Datum) 0;

}

/*

* CREATE PROCEDURE dbms_sql.bind_variable(c int, name varchar2, value "any");

*/

Datum

dbms_sql_bind_variable(PG_FUNCTION_ARGS)

{

return bind_variable(fcinfo);

}

/*

* CREATE FUNCTION dbms_sql.bind_variable_f(c int, name varchar2, value "any") RETURNS void;

*/

Datum

dbms_sql_bind_variable_f(PG_FUNCTION_ARGS)

{

return bind_variable(fcinfo);

}

static void

bind_array(FunctionCallInfo fcinfo, int index1, int index2)

{

CursorData *c;

VariableData *var;

char *varname,

*varname_downcase;

Oid valtype;

Oid elementtype;

c = get_cursor(fcinfo, true);

if (PG_ARGISNULL(1))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("name of bind variable is NULL")));

varname = text_to_cstring(PG_GETARG_TEXT_P(1));

if (*varname == ':')

varname += 1;

varname_downcase = downcase_identifier(varname, (int) strlen(varname), false, true);

var = get_var(c, varname_downcase, -1, false);

valtype = get_fn_expr_argtype(fcinfo->flinfo, 2);

if (valtype == RECORDOID)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("cannot to bind a value of record type")));

valtype = getBaseType(valtype);

elementtype = get_element_type(valtype);

if (!OidIsValid(elementtype))

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("value is not a array")));

if (var->typoid != InvalidOid)

{

if (!var->typbyval && !var->isnull)

{

pfree(DatumGetPointer(var->value));

var->value = (Datum) 0;

}

var->isnull = true;

}

var->is_array = true;

var->typoid = valtype;

var->typelemid = elementtype;

get_typlenbyval(elementtype, &var->typelemlen, &var->typelembyval);

if (!PG_ARGISNULL(2))

{

MemoryContext oldcxt;

get_typlenbyval(var->typoid, &var->typlen, &var->typbyval);

oldcxt = MemoryContextSwitchTo(c->cursor_cxt);

var->value = datumCopy(PG_GETARG_DATUM(2), var->typbyval, var->typlen);

var->isnull = false;

MemoryContextSwitchTo(oldcxt);

}

else

var->isnull = true;

var->index1 = index1;

var->index2 = index2;

}

/*

* CREATE PROCEDURE dbms_sql.bind_array(c int, name varchar2, value anyarray);

*/

Datum

dbms_sql_bind_array_3(PG_FUNCTION_ARGS)

{

bind_array(fcinfo, -1, -1);

return (Datum) 0;

}

/*

* CREATE PROCEDURE dbms_sql.bind_array(c int, name varchar2, value anyarray, index1 int, index2 int);

*/

Datum

dbms_sql_bind_array_5(PG_FUNCTION_ARGS)

{

int index1,

index2;

if (PG_ARGISNULL(3) || PG_ARGISNULL(4))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("index is NULL")));

index1 = PG_GETARG_INT32(3);

index2 = PG_GETARG_INT32(4);

if (index1 < 0 || index2 < 0)

ereport(ERROR,

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("index is below zero")));

if (index1 > index2)

ereport(ERROR,

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("index1 is greater than index2")));

bind_array(fcinfo, index1, index2);

return (Datum) 0;

}

static ColumnData *

get_col(CursorData *c, int position, bool append)

{

ListCell *lc;

foreach(lc, c->columns)

{

ColumnData *col = (ColumnData *) lfirst(lc);

if (col->position == position)

return col;

}

if (append)

{

ColumnData *ncol;

MemoryContext oldcxt;

oldcxt = MemoryContextSwitchTo(c->cursor_cxt);

ncol = palloc0(sizeof(ColumnData));

ncol->position = position;

if (c->max_colpos < position)

c->max_colpos = position;

c->columns = lappend(c->columns, ncol);

MemoryContextSwitchTo(oldcxt);

return ncol;

}

else

ereport(ERROR,

(errcode(ERRCODE_UNDEFINED_COLUMN),

errmsg("column no %d is not defined", position)));

/* be msvc quite */

return NULL;

}

/*

* CREATE PROCEDURE dbms_sql.define_column(c int, col int, value "any", column_size int DEFAULT -1);

*/

Datum

dbms_sql_define_column(PG_FUNCTION_ARGS)

{

CursorData *c;

ColumnData *col;

Oid valtype;

Oid basetype;

int position;

int colsize;

TYPCATEGORY category;

bool ispreferred;

c = get_cursor(fcinfo, true);

if (PG_ARGISNULL(1))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("column position (number) is NULL")));

position = PG_GETARG_INT32(1);

col = get_col(c, position, true);

valtype = get_fn_expr_argtype(fcinfo->flinfo, 2);

if (valtype == RECORDOID)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("cannot to define a column of record type")));

if (valtype == UNKNOWNOID)

valtype = TEXTOID;

basetype = getBaseType(valtype);

if (col->typoid != InvalidOid)

ereport(ERROR,

(errcode(ERRCODE_DUPLICATE_COLUMN),

errmsg("column is defined already")));

col->typoid = valtype;

if (PG_ARGISNULL(3))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("column_size is NULL")));

colsize = PG_GETARG_INT32(3);

get_type_category_preferred(basetype, &category, &ispreferred);

col->typisstr = category == TYPCATEGORY_STRING;

col->typmod = (col->typisstr && colsize != -1) ? colsize + 4 : -1;

get_typlenbyval(basetype, &col->typlen, &col->typbyval);

col->rowcount = 1;

return (Datum) 0;

}

/*

* CREATE PROCEDURE dbms_sql.define_array(c int, col int, value "anyarray", rowcount int, index1 int);

*/

Datum

dbms_sql_define_array(PG_FUNCTION_ARGS)

{

CursorData *c;

ColumnData *col;

Oid valtype;

Oid basetype;

int position;

int rowcount;

int index1;

Oid elementtype;

TYPCATEGORY category;

bool ispreferred;

c = get_cursor(fcinfo, true);

if (PG_ARGISNULL(1))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("column position (number) is NULL")));

position = PG_GETARG_INT32(1);

col = get_col(c, position, true);

valtype = get_fn_expr_argtype(fcinfo->flinfo, 2);

if (valtype == RECORDOID)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("cannot to define a column of record type")));

get_type_category_preferred(valtype, &category, &ispreferred);

if (category != TYPCATEGORY_ARRAY)

elog(ERROR, "defined value is not array");

col->typarrayoid = valtype;

basetype = getBaseType(valtype);

elementtype = get_element_type(basetype);

if (!OidIsValid(elementtype))

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("column is not a array")));

if (col->typoid != InvalidOid)

ereport(ERROR,

(errcode(ERRCODE_DUPLICATE_COLUMN),

errmsg("column is defined already")));

col->typoid = elementtype;

if (PG_ARGISNULL(3))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("cnt is NULL")));

rowcount = PG_GETARG_INT32(3);

if (rowcount <= 0)

ereport(ERROR,

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("cnt is less or equal to zero")));

col->rowcount = (uint64) rowcount;

if (PG_ARGISNULL(4))

ereport(ERROR,

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

errmsg("lower_bnd is NULL")));

index1 = PG_GETARG_INT32(4);

if (index1 < 1)

ereport(ERROR,

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("lower_bnd is less than one")));

if (index1 != 1)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("lower_bnd can be only only \"1\"")));

col->index1 = index1;

get_typlenbyval(col->typoid, &col->typlen, &col->typbyval);

return (Datum) 0;

}

static void

cursor_xact_cxt_deletion_callback(void *arg)

{

CursorData *cur = (CursorData *) arg;

cur->cursor_xact_cxt = NULL;

cur->result_cxt = NULL;

cur->tuples_cxt = NULL;

cur->processed = 0;

cur->nread = 0;

cur->executed = false;

cur->tupdesc = NULL;

cur->coltupdesc = NULL;

cur->casts = NULL;

cur->array_columns = NULL;

}

static uint64

execute(CursorData *c)

{

last_row_count = 0;

/* clean space with saved result */

if (!c->cursor_xact_cxt)

{

MemoryContextCallback *mcb;

MemoryContext oldcxt;

c->cursor_xact_cxt = AllocSetContextCreate(TopTransactionContext,

"dbms_sql transaction context",

ALLOCSET_DEFAULT_SIZES);

oldcxt = MemoryContextSwitchTo(c->cursor_xact_cxt);

mcb = palloc0(sizeof(MemoryContextCallback));

mcb->func = cursor_xact_cxt_deletion_callback;

mcb->arg = c;

MemoryContextRegisterResetCallback(c->cursor_xact_cxt, mcb);

MemoryContextSwitchTo(oldcxt);

}

else

{

MemoryContext save_cxt = c->cursor_xact_cxt;

MemoryContextReset(c->cursor_xact_cxt);

c->cursor_xact_cxt = save_cxt;

c->casts = NULL;

c->tupdesc = NULL;

c->tuples_cxt = NULL;

}

c->result_cxt = AllocSetContextCreate(c->cursor_xact_cxt,

"dbms_sql short life context",

ALLOCSET_DEFAULT_SIZES);

/*

* When column definitions are available, build final query and open

* cursor for fetching. When column definitions are missing, then the

* statement can be called with high frequency etc INSERT, UPDATE, so use

* cached plan.

*/

if (c->columns)

{

Datum *values;

Oid *types;

char *nulls;

ListCell *lc;

int i;

MemoryContext oldcxt;

uint64 batch_rows = 0;

oldcxt = MemoryContextSwitchTo(c->cursor_xact_cxt);

/* prepare query arguments */

values = palloc(sizeof(Datum) * c->nvariables);

types = palloc(sizeof(Oid) * c->nvariables);

nulls = palloc(sizeof(char) * c->nvariables);

i = 0;

foreach(lc, c->variables)

{

VariableData *var = (VariableData *) lfirst(lc);

if (var->is_array)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("a array (bulk) variable can be used only when no column is defined")));

if (!var->isnull)

{

/*

* copy a value to xact memory context, to be independent on a

* outside

*/

values[i] = datumCopy(var->value, var->typbyval, var->typlen);

nulls[i] = ' ';

}