[Jc @ s) d Z d Z d e f d YZ d S( s
Provides an API for creation of custom ClauseElements and compilers.
Synopsis
========
Usage involves the creation of one or more :class:`~sqlalchemy.sql.expression.ClauseElement`
subclasses and one or more callables defining its compilation::
from sqlalchemy.ext.compiler import compiles
from sqlalchemy.sql.expression import ColumnClause
class MyColumn(ColumnClause):
pass
@compiles(MyColumn)
def compile_mycolumn(element, compiler, **kw):
return "[%s]" % element.name
Above, ``MyColumn`` extends :class:`~sqlalchemy.sql.expression.ColumnClause`, the
base expression element for column objects. The ``compiles`` decorator registers
itself with the ``MyColumn`` class so that it is invoked when the object
is compiled to a string::
from sqlalchemy import select
s = select([MyColumn('x'), MyColumn('y')])
print str(s)
Produces::
SELECT [x], [y]
Compilers can also be made dialect-specific. The appropriate compiler will be invoked
for the dialect in use::
from sqlalchemy.schema import DDLElement # this is a SQLA 0.6 construct
class AlterColumn(DDLElement):
def __init__(self, column, cmd):
self.column = column
self.cmd = cmd
@compiles(AlterColumn)
def visit_alter_column(element, compiler, **kw):
return "ALTER COLUMN %s ..." % element.column.name
@compiles(AlterColumn, 'postgres')
def visit_alter_column(element, compiler, **kw):
return "ALTER TABLE %s ALTER COLUMN %s ..." % (element.table.name, element.column.name)
The second ``visit_alter_table`` will be invoked when any ``postgres`` dialect is used.
The ``compiler`` argument is the :class:`~sqlalchemy.engine.base.Compiled` object
in use. This object can be inspected for any information about the in-progress
compilation, including ``compiler.dialect``, ``compiler.statement`` etc.
The :class:`~sqlalchemy.sql.compiler.SQLCompiler` and :class:`~sqlalchemy.sql.compiler.DDLCompiler` (DDLCompiler is 0.6. only)
both include a ``process()`` method which can be used for compilation of embedded attributes::
class InsertFromSelect(ClauseElement):
def __init__(self, table, select):
self.table = table
self.select = select
@compiles(InsertFromSelect)
def visit_insert_from_select(element, compiler, **kw):
return "INSERT INTO %s (%s)" % (
compiler.process(element.table, asfrom=True),
compiler.process(element.select)
)
insert = InsertFromSelect(t1, select([t1]).where(t1.c.x>5))
print insert
Produces::
"INSERT INTO mytable (SELECT mytable.x, mytable.y, mytable.z FROM mytable WHERE mytable.x > :x_1)"
c s f d } | S( Nc s t d d p6 t t d f d t d n o" x, D] } | i | Y s t default( t getattrt Nonet _dispatchert setattrt specs( t fnt s( t class_R ( R s; /usr/lib/python2.6/site-packages/sqlalchemy/ext/compiler.pyt decorateS s
( ( R R R ( ( R R s; /usr/lib/python2.6/site-packages/sqlalchemy/ext/compiler.pyt compilesR s R c B s e Z d Z d Z RS( c C s
h | _ d S( N( R ( t self( ( s; /usr/lib/python2.6/site-packages/sqlalchemy/ext/compiler.pyt __init__e s c K sC | i i | i i d } | p | i d } n | | | | S( NR ( R t gett dialectt nameR ( R t elementt compilerR R ( ( s; /usr/lib/python2.6/site-packages/sqlalchemy/ext/compiler.pyt __call__h s ( t __name__t
__module__R R ( ( ( s; /usr/lib/python2.6/site-packages/sqlalchemy/ext/compiler.pyR d s N( t __doc__R t objectR ( ( ( s; /usr/lib/python2.6/site-packages/sqlalchemy/ext/compiler.pyt P s