PostgreSQL 9.0.4 Documentation
Prev | Fast Backward | Chapter 42. PL/Python - Python Procedural Language | Fast Forward | Next

# 42.7. 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``.

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_execute()` 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.

Query parameters and result row fields are converted between PostgreSQL and Python data types as described in Section 42.3. The exception is that composite types are currently not supported: They will be rejected as query parameters and are converted to strings when appearing in a query result. As a workaround for the latter problem, the query can sometimes be rewritten so that the composite type result appears as a result row rather than as a field of the result row. Alternatively, the resulting string could be parsed apart by hand, but this approach is not recommended because it is not future-proof.

When you prepare a plan using the PL/Python module it is automatically saved. Read the SPI documentation (Chapter 43) 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 42.4). 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;

Prev | Home | Next
Trigger Functions | Up | Utility Functions