The third argument is the optional row limit as before.

</para>

<para>

Alternatively, you can call the <function>execute</function> method on

the plan object:

<programlisting>

rv = plan.execute(["name"], 5)

</programlisting>

</para>

<para>

Query parameters and result row fields are converted between PostgreSQL

and Python data types as described in <xref linkend="plpython-data">.

as <literal>plpy.execute</literal> (except for the row limit) and returns

a cursor object, which allows you to process large result sets in smaller

chunks. As with <literal>plpy.execute</literal>, either a query string

or a plan object along with a list of arguments can be used.

or a plan object along with a list of arguments can be used, or

the <function>cursor</function> function can be called as a method of

the plan object.

</para>

<para>

CREATE FUNCTION count_odd_prepared() RETURNS integer AS $$

odd = 0

plan = plpy.prepare("select num from largetable where num % $1 &lt;&gt; 0", ["integer"])

rows = list(plpy.cursor(plan, [2]))

rows = list(plpy.cursor(plan, [2])) # or: = list(plan.cursor([2]))

return len(rows)

$$ LANGUAGE plpythonu;

except Exception, ex:

plpy.error(str(ex))

return None

'

LANGUAGE plpythonu;

CREATE FUNCTION spi_prepared_plan_test_two(a text) RETURNS text

AS

'if "myplan" not in SD:

q = "SELECT count(*) FROM users WHERE lname = $1"

SD["myplan"] = plpy.prepare(q, [ "text" ])

try:

rv = SD["myplan"].execute([a])

return "there are " + str(rv[0]["count"]) + " " + str(a) + "s"

except Exception, ex:

plpy.error(str(ex))

return None

'

LANGUAGE plpythonu;

CREATE FUNCTION spi_prepared_plan_test_nested(a text) RETURNS text

there are 3 does

(1 row)

selectspi_prepared_plan_test_one('smith');

selectspi_prepared_plan_test_two('smith');

----------------------------

there are 1 smiths

(1 row)

["text"])

for row in plpy.cursor(plan, ["w"]):

yield row['fname']

for row inplpy.cursor(plan,["j"]):

for row inplan.cursor(["j"]):

yield row['fname']

$$ LANGUAGE plpythonu;

CREATE FUNCTION cursor_plan_wrong_args() RETURNS SETOF text AS $$

staticPyObject*PLy_cursor_query(constchar*query);

staticPyObject*PLy_cursor_plan(PyObject*ob,PyObject*args);

staticvoidPLy_cursor_dealloc(PyObject*arg);

staticPyObject*PLy_cursor_iternext(PyObject*self);

staticPyObject*PLy_cursor_fetch(PyObject*self,PyObject*args);

return (PyObject*)cursor;

}

PLy_cursor_plan(PyObject*ob,PyObject*args)

{

PLyCursorObject*cursor;

externvoidPLy_cursor_init_type(void);

externPyObject*PLy_cursor(PyObject*self,PyObject*args);

externPyObject*PLy_cursor_plan(PyObject*ob,PyObject*args);

staticvoidPLy_plan_dealloc(PyObject*arg);

staticPyObject*PLy_plan_cursor(PyObject*self,PyObject*args);

staticPyObject*PLy_plan_execute(PyObject*self,PyObject*args);

staticPyObject*PLy_plan_status(PyObject*self,PyObject*args);

staticcharPLy_plan_doc[]= {

};

staticPyMethodDefPLy_plan_methods[]= {

{"cursor",PLy_plan_cursor,METH_VARARGS,NULL},

{"execute",PLy_plan_execute,METH_VARARGS,NULL},

{"status",PLy_plan_status,METH_VARARGS,NULL},

{NULL,NULL,0,NULL}

};

}

PLy_plan_cursor(PyObject*self,PyObject*args)

{

PyObject*planargs=NULL;

if (!PyArg_ParseTuple(args,"|O",&planargs))

returnNULL;

returnPLy_cursor_plan(self,planargs);

}

PLy_plan_execute(PyObject*self,PyObject*args)

{

PyObject*list=NULL;

longlimit=0;

if (!PyArg_ParseTuple(args,"|Ol",&list,&limit))

returnNULL;

returnPLy_spi_execute_plan(self,list,limit);

}

PLy_plan_status(PyObject*self,PyObject*args)

{

staticPyObject*PLy_spi_execute_query(char*query,longlimit);

staticPyObject*PLy_spi_execute_plan(PyObject*ob,PyObject*list,longlimit);

staticPyObject*PLy_spi_execute_fetch_result(SPITupleTable*tuptable,

uint64rows,intstatus);

staticvoidPLy_spi_exception_set(PyObject*excclass,ErrorData*edata);

returnNULL;

}

PLy_spi_execute_plan(PyObject*ob,PyObject*list,longlimit)

{

volatileintnargs;

externPyObject*PLy_spi_prepare(PyObject*self,PyObject*args);

externPyObject*PLy_spi_execute(PyObject*self,PyObject*args);

externPyObject*PLy_spi_execute_plan(PyObject*ob,PyObject*list,longlimit);

{

LANGUAGE plpythonu;

CREATEFUNCTIONspi_prepared_plan_test_two(atext) RETURNStext

LANGUAGE plpythonu;

CREATEFUNCTIONspi_prepared_plan_test_nested(atext) RETURNStext

select nested_call_one('pass this along');

select spi_prepared_plan_test_one('doe');

selectspi_prepared_plan_test_one('smith');

selectspi_prepared_plan_test_two('smith');

select spi_prepared_plan_test_nested('smith');

SELECT join_sequences(sequences)FROM sequences;

["text"])

for rowinplpy.cursor(plan, ["w"]):

yield row['fname']

for rowinplpy.cursor(plan,["j"]):

for rowinplan.cursor(["j"]):

yield row['fname']

$$ LANGUAGE plpythonu;