Database Access

PostgreSQL 7.3.4 Documentation
Prev | Chapter 22. PL/Python - Python Procedural Language | Next

# 22.3. Database Access

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 field 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 variable. 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_field, it would be accessed as

    foo = rv[i]["my_field"]

The second function `plpy.prepare` is called with a query string and a list of argument types if you have bind variables 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 as $1. After preparing a statement, you use the function `plpy.execute` to run it:

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

The limit argument is optional in the call to `plpy.execute`.

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 17) 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 22.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 'plpython';

Prev | Home | Next
Trigger Functions | Up | Restricted Environment