python_includespec

python_configdir

python_version

python_majorversion

PYTHON

perl_embed_ldflags

perl_useshrplib

fi

{ $as_echo "$as_me:$LINENO: checking Python configuration directory" >&5

$as_echo_n "checking Python configuration directory... " >&6; }

python_majorversion=`${PYTHON} -c "import sys; print(sys.version[0])"`

python_version=`${PYTHON} -c "import sys; print(sys.version[:3])"`

python_configdir=`${PYTHON} -c "from distutils.sysconfig import get_python_lib as f; import os; print(os.path.join(f(plat_specific=1,standard_lib=1),'config'))"`

python_includespec=`${PYTHON} -c "import distutils.sysconfig; print('-I'+distutils.sysconfig.get_python_inc())"`

<!-- $PostgreSQL: pgsql/doc/src/sgml/installation.sgml,v 1.332 2009/12/09 16:16:34 mha Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/installation.sgml,v 1.333 2009/12/15 22:59:53 petere Exp $ -->

<chapter id="installation">

<title><![%standalone-include[<productname>PostgreSQL</>]]>

<para>

To build the <application>PL/Python</> server programming

language, you need a <productname>Python</productname>

installation with the header files and the <application>distutils</application> module.

The minimum required version is <productname>Python</productname> 2.2.

installation with the header files and

the <application>distutils</application> module. The minimum

required version is <productname>Python</productname>

2.2. <productname>Python 3</productname> is supported with

version 3.1 or later; but see <xref linkend="plpython-python23">

when using Python 3.

</para>

<para>

<!-- $PostgreSQL: pgsql/doc/src/sgml/plpython.sgml,v 1.41 2009/12/10 20:43:40 petere Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/plpython.sgml,v 1.42 2009/12/15 22:59:53 petere Exp $ -->

<chapter id="plpython">

<title>PL/Python - Python Procedural Language</title>

<para>

To install PL/Python in a particular database, use

<literal>createlang plpythonu <replaceable>dbname</></literal>.

<literal>createlang plpythonu <replaceable>dbname</></literal> (but

see also <xref linkend="plpython-python23">).

</para>

<tip>

</para>

</note>

<sect1 id="plpython-python23">

<title>Python 2 vs. Python 3</title>

<para>

PL/Python supports both the Python 2 and Python 3 language

variants. (The PostgreSQL installation instructions might contain

more precise information about the exact supported minor versions

of Python.) Because the Python 2 and Python 3 language variants

are incompatible in some important aspects, the following naming

and transitioning scheme is used by PL/Python to avoid mixing them:

<itemizedlist>

<listitem>

<para>

The PostgreSQL language named <literal>plpython2u</literal>

implements PL/Python based on the Python 2 language variant.

</para>

</listitem>

<listitem>

<para>

The PostgreSQL language named <literal>plpython3u</literal>

implements PL/Python based on the Python 3 language variant.

</para>

</listitem>

<listitem>

<para>

The language named <literal>plpythonu</literal> implements

PL/Python based on the default Python language variant, which is

currently Python 2. (This default is independent of what any

local Python installations might consider to be

their <quote>default</quote>, for example,

what <filename>/usr/bin/python</filename> might be.) The

default will probably be changed to Python 3 in a distant future

release of PostgreSQL, depending on the progress of the

migration to Python 3 in the Python community.

</para>

</listitem>

</itemizedlist>

It depends on the build configuration or the installed packages

whether PL/Python for Python 2 or Python 3 or both are available.

</para>

<para>

This results in the following usage and migration strategy:

<itemizedlist>

<listitem>

<para>

Existing users and users who are currently not interested in

Python 3 use the language name <literal>plpythonu</literal> and

don't have to change anything for the foreseeable future. It is

recommended to gradually <quote>future-proof</quote> the code

via migration to Python 2.6/2.7 to simplify the eventual

migration to Python 3.

</para>

<para>

In practice, many PL/Python functions will migrate to Python 3

with few or no changes.

</para>

</listitem>

<listitem>

<para>

Users who know that they have heavily Python 2 dependent code

and don't plan to ever change it can make use of

the <literal>plpython2u</literal> language name. This will

continue to work into the very distant future, until Python 2

support might be completely dropped by PostgreSQL.

</para>

</listitem>

<listitem>

<para>

Users who want to dive into Python 3 can use

the <literal>plpython3u</literal> language name, which will keep

working forever by today's standards. In the distant future,

when Python 3 might become the default, they might like to

remove the <quote>3</quote> for aesthetic reasons.

</para>

</listitem>

<listitem>

<para>

Daredevils, who want to build a Python-3-only operating system

environment, can change the build scripts to

make <literal>plpythonu</literal> be equivalent

to <literal>plpython3u</literal>, keeping in mind that this

would make their installation incompatible with most of the rest

of the world.

</para>

</listitem>

</itemizedlist>

</para>

<para>

See also the

document <ulink url="http://docs.python.org/dev/3.0/whatsnew/3.0.html">What's

New In Python 3.0</ulink> for more information about porting to

Python 3.

</para>

</sect1>

<sect1 id="plpython-funcs">

<title>PL/Python Functions</title>

python_libspec= @python_libspec@

python_additional_libs= @python_additional_libs@

python_configdir= @python_configdir@

python_majorversion= @python_majorversion@

python_version= @python_version@

krb_srvtab = @krb_srvtab@

DATA(insert ("plperl"tt"plperl_call_handler""plperl_inline_handler""plperl_validator""$libdir/plperl"_null_ ));

DATA(insert ("plperlu"ff"plperl_call_handler""plperl_inline_handler""plperl_validator""$libdir/plperl"_null_ ));

DATA(insert ("plpythonu"ff"plpython_call_handler"_null__null_"$libdir/plpython"_null_ ));

DATA(insert ("plpython2u"ff"plpython_call_handler"_null__null_"$libdir/plpython2"_null_ ));

DATA(insert ("plpython3u"ff"plpython_call_handler"_null__null_"$libdir/plpython3"_null_ ));

subdir = src/pl/plpython

top_builddir = ../../..

rpathdir =$(python_libdir)

NAME = plpython

NAME = plpython$(python_majorversion)

OBJS = plpython.o

SHLIB_LINK =$(python_libspec)$(python_additional_libs)$(filter -lintl,$(LIBS))

REGRESS_OPTS = --dbname=$(PL_TESTDB) --load-language=plpythonu

REGRESS_OPTS = --dbname=$(PL_TESTDB)

ifeq ($(python_majorversion),2)

REGRESS_OPTS += --load-language=plpythonu

REGRESS =\

plpython_schema\

plpython_populate\

all: all-lib

install: all installdirs install-lib

ifeq ($(python_majorversion),2)

cd '$(DESTDIR)$(pkglibdir)' && rm -f plpython$(DLSUFFIX) && $(LN_S) $(shlib) plpython$(DLSUFFIX)

installdirs: installdirs-lib

uninstall: uninstall-lib

ifeq ($(python_majorversion),2)

rm -f '$(DESTDIR)$(pkglibdir)/plpython$(DLSUFFIX)'

ifeq ($(python_majorversion),3)

prep3:

$(MKDIR_P) python3 python3/sql python3/expected

forfilein$(srcdir)/sql/*.sql$(srcdir)/expected/*.out;do \

sed -e's/except \([[:alpha:]][[:alpha:].]*\), *\([[:alpha:]][[:alpha:]]*\):/except \1 as \2:/g'\

-e"s/<type 'exceptions\.\([[:alpha:]]*\)'>/<class '\1'>/g"\

-e"s/<type 'long'>/<class 'int'>/g"\

-e"s/\([0-9][0-9]*\)L/\1/g"\

-e's/\([ [{]\)u"/\1"/g'\

-e"s/\([ [{]\)u'/\1'/g"\

-e"s/def next/def __next__/g"\

-e"s/LANGUAGE plpythonu/LANGUAGE plpython3u/g"\

-e"s/LANGUAGE plpython2u/LANGUAGE plpython3u/g"\

$$file>`echo$$file| sed's,$(srcdir),python3,'`;\

clean3:

rm -rf python3/

installcheck: submake prep3

$(top_builddir)/src/test/regress/pg_regress --inputdir=./python3 --outputdir=./python3 --psqldir=$(PSQLDIR)$(REGRESS_OPTS)$(REGRESS)

clean: clean3

installcheck: submake

$(top_builddir)/src/test/regress/pg_regress --inputdir=$(srcdir) --psqldir=$(PSQLDIR)$(REGRESS_OPTS)$(REGRESS)

.PHONY: submake

submake:

plpython_unicode_2.outPython 2.2

plpython_unicode_3.outPython 2.3, 2.4

plpython_unicode_5.outPython 2.5, 2.6

plpython_types_3.outPython 3.1

-- first some tests of basic functionality

CREATE LANGUAGE plpython2u;

-- really stupid function just to get the module loaded

CREATE FUNCTION stupid() RETURNS text AS 'return "zarkon"' LANGUAGE plpythonu;

select stupid();

zarkon

(1 row)

-- check 2/3 versioning

CREATE FUNCTION stupidn() RETURNS text AS 'return "zarkon"' LANGUAGE plpython2u;

select stupidn();

stupidn

---------

zarkon

(1 row)

-- test multiple arguments

CREATE FUNCTION argument_test_one(u users, a1 text, a2 text) RETURNS text

AS

-- dump trigger data

CREATE TABLE trigger_test

(i int, v text );

CREATE FUNCTION trigger_data()returns triggerlanguage plpythonuas $$

CREATE FUNCTION trigger_data()RETURNS triggerLANGUAGE plpythonuAS $$

if 'relid' in TD:

TD['relid'] = "bogus:12345"