| PostgreSQL 7.4 Documentation | ||||
|---|---|---|---|---|
| Prev | Fast Backward | Chapter 40. PL/Python - Python Procedural Language | Fast Forward | Next | 
   The PL/Python language module automatically imports a Python module
   called plpy.  The functions and constants in
   this module are available to you in the Python code as
   plpy.foo.  At present
   plpy implements the functions
   plpy.debug("msg"),
   plpy.log("msg"),
   plpy.info("msg"),
   plpy.notice("msg"),
   plpy.warning("msg"),
   plpy.error("msg"), and
   plpy.fatal("msg").  They are mostly equivalent
   to calling elog(LEVEL, "msg")
   from C code.  plpy.error and
   plpy.fatal actually raise a Python exception
   which, if uncaught, causes the PL/Python module to call
   elog(ERROR, msg) when the function handler
   returns from the Python interpreter.  Long-jumping out of the
   Python interpreter is probably not good.  raise
   plpy.ERROR("msg") and raise
   plpy.FATAL("msg") are equivalent to calling
   plpy.error and
   plpy.fatal, respectively.
  
   Additionally, the plpy module provides two
   functions called execute and
   prepare.  Calling
   plpy.execute with a query string and an
   optional limit argument causes that query to be run and the result
   to be returned in a result object.  The result object emulates a
   list or dictionary object.  The result object can be accessed by
   row number and column name.  It has these additional methods:
   nrows which returns the number of rows
   returned by the query, and status which is the
   SPI_exec() return value.  The result object
   can be modified.
  
For example,
rv = plpy.execute("SELECT * FROM my_table", 5)returns up to 5 rows from my_table. If my_table has a column my_column, it would be accessed as
foo = rv[i]["my_column"]
   
   The second function, plpy.prepare, prepares
   the execution plan for a query.  It is called with a query string
   and a list of parameter types, if you have parameter references in
   the query.  For example:
plan = plpy.prepare("SELECT last_name FROM my_users WHERE first_name = $1", [ "text" ])
   text is the type of the variable you will be
   passing for $1.  After preparing a statement, you
   use the function plpy.execute to run it:
rv = plpy.execute(plan, [ "name" ], 5)
The third argument is the limit and is optional.
In the current version, any database error encountered while running a PL/Python function will result in the immediate termination of that function by the server; it is not possible to trap error conditions using Python try ... catch constructs. For example, a syntax error in an SQL statement passed to the plpy.execute call will terminate the function. This behavior may be changed in a future release.
When you prepare a plan using the PL/Python module it is automatically saved. Read the SPI documentation (Chapter 41) for a description of what this means. In order to make effective use of this across function calls one needs to use one of the persistent storage dictionaries SD or GD (see Section 40.1). For example:
CREATE FUNCTION usesavedplan() RETURNS trigger AS '
    if SD.has_key("plan"):
        plan = SD["plan"]
    else:
        plan = plpy.prepare("SELECT 1")
        SD["plan"] = plan
    # rest of function
' LANGUAGE plpythonu;