�
���ec@s�
dZd
dl
mZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlm	Z	
ddl
m
Z

dd	l
mZ
eZ
eZeZeZeZeZeZeZeZd
ef
d��YZdeje	fd
��YZdef
d��YZdejeee�f
d��YZdef
d��YZdef
d��YZdeeefd��YZdef
d��YZ ed�
Z!d�Z"d�Z#dS(sBase types API.

i
(
t	operators(
tSchemaEventTarget(
tNO_CACHE(
tTraversible(
tTraversibleTypei(
texc(
tutilt
TypeEnginecBs�
eZ
dZeZeZeZeZeZ	eZ
d
ejf
d��YZ
eZe
Zd(ZeZd�Zd�Zd�Zd�Zd�Zd�Zd	�Zd
�Zejd��
Zd�Zejd
��
Ze d��
Z!d�Z"d�Z#e$d��
Z%d�Z&d�Z'ejd��
Z(ejd��
Z)ed�
Z*d�Z+d�Z,d�Z-d�Z.d�Z/d�Z0d�Z1d�Z2ejd��
Z3d �Z4d!�Z5d"�Z6d(d#�
Z7ej8d$�
d%��
Z9d&�Z:d'�Z;RS()s1
The ultimate base class for all SQL datatypes.

    Common subclasses of :class:`.TypeEngine` include
    :class:`.String`, :class:`.Integer`, and :class:`.Boolean`.

    For an overview of the SQLAlchemy typing system, see
    :ref:`types_toplevel`.

    .. seealso::

        :ref:`types_toplevel`

    t
ComparatorcBsneZ
dZd
ZdZd�Zd�Zej	d�
d��
Z
ej	d�
d��
Zd�Zd	�Z
RS(s�Base class for custom comparison operations defined at the
        type level.  See :attr:`.TypeEngine.comparator_factory`.


        texprttypec


Cs|jS(
N(
R	(
tself((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt__clause_element__Bs
cCs|
|_|
j
|_
dS(
N(R	R
(RR	((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt__init__Es
	
s!sqlalchemy.sql.default_comparatorcOs>tj
j}|j|
j}|d
|j|
||d|�S(Nii
(Rt	preloadedtsql_default_comparatortoperator_lookupt__name__R	(Rtoptothertkwargstdefault_comparatort
o((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytoperateIs

cKsCtj
j}|j|
j}|d
|j|
|dt|d|�
S(Nitreversei
(RRRRRR	tTrue(RRRRRR((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytreverse_operateOs

cCs
|
|jfS(
sOevaluate the return type of <self> <op> <othertype>,
            and apply any adaptations to the given operator.

            This method determines the type of a resulting binary expression
            given two source types and an operator.   For example, two
            :class:`_schema.Column` objects, both of the type
            :class:`.Integer`, will
            produce a :class:`.BinaryExpression` that also has the type
            :class:`.Integer` when compared via the addition (``+``) operator.
            However, using the addition operator with an :class:`.Integer`
            and a :class:`.Date` object will produce a :class:`.Date`, assuming
            "days delta" behavior by the database (in reality, most databases
            other than PostgreSQL don't accept this particular operation).

            The method returns a tuple of the form <operator>, <type>.
            The resulting operator and type will be those applied to the
            resulting :class:`.BinaryExpression` as the final operator and the
            right-hand side of the expression.

            Note that only a subset of operators make usage of
            :meth:`._adapt_expression`,
            including math operators and user-defined operators, but not
            boolean comparison or special SQL keywords like MATCH or BETWEEN.

            (
R
(RRtother_comparator((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_adapt_expressionUsc

Cst|j
|j
jffS(
N(t_reconstitute_comparatorR	R
(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt
__reduce__vs
(R	R
N(Rt
__module__t__doc__t	__slots__tNoneRRR
Rtpreload_moduleRRRR(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR7s			!c
Cs|j�}
t
|
_|
S(
s�Return a copy of this type which has the
        :attr:`.should_evaluate_none` flag set to True.

        E.g.::

                Table(
                    'some_table', metadata,
                    Column(
                        String(50).evaluates_none(),
                        nullable=True,
                        server_default='no value')
                )

        The ORM uses this flag to indicate that a positive value of ``None``
        is passed to the column in an INSERT statement, rather than omitting
        the column from the INSERT statement which has the effect of firing
        off column-level defaults.   It also allows for types which have
        special behavior associated with the Python None value to indicate
        that the value doesn't necessarily translate into SQL NULL; a
        prime example of this is a JSON type which may wish to persist the
        JSON value ``'null'``.

        In all cases, the actual NULL SQL value can be always be
        persisted in any column by using
        the :obj:`_expression.null` SQL construct in an INSERT statement
        or associated with an ORM-mapped attribute.

        .. note::

            The "evaluates none" flag does **not** apply to a value
            of ``None`` passed to :paramref:`_schema.Column.default` or
            :paramref:`_schema.Column.server_default`; in these cases,
            ``None``
            still means "no default".

        .. versionadded:: 1.1

        .. seealso::

            :ref:`session_forcing_null` - in the ORM documentation

            :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
            interaction with this flag.

            :attr:`.TypeEngine.should_evaluate_none` - class-level flag

        (tcopyRtshould_evaluate_none(Rttyp((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytevaluates_none�s0
	
c
Ks|j|j
�
S(
N(tadaptt	__class__(Rtkw((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR$�s
c
Csd
S(s�Compare this type against the given backend type.

        This function is currently not implemented for SQLAlchemy
        types, and for all built in types will return ``None``.  However,
        it can be implemented by a user-defined type
        where it can be consumed by schema comparison tools such as
        Alembic autogenerate.

        A future release of SQLAlchemy will potentially implement this method
        for builtin types as well.

        The function should return True if this type is equivalent to the
        given type; the type is typically reflected from the database
        so should be database specific.  The dialect in use is also
        passed.   It can also return False to assert that the type is
        not equivalent.

        :param dialect: a :class:`.Dialect` that is involved in the comparison.

        :param conn_type: the type object reflected from the backend.

        .. versionadded:: 1.0.3

        N(
R"(Rtdialectt	conn_type((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytcompare_against_backend�sc
Cs|
S(
N((Rtvalue((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt
copy_value
s
c
Csd
S(smReturn a conversion function for processing literal values that are
        to be rendered directly without using binds.

        This function is used when the compiler makes use of the
        "literal_binds" flag, typically used in DDL generation as well
        as in certain scenarios where backends don't accept bound parameters.

        Returns a callable which will receive a literal Python value
        as the sole positional argument and will return a string representation
        to be rendered in a SQL statement.

        .. note::

            This method is only called relative to a **dialect specific type
            object**, which is often **private to a dialect in use** and is not
            the same type object as the public facing one, which means it's not
            feasible to subclass a :class:`.types.TypeEngine` class in order to
            provide an alternate :meth:`_types.TypeEngine.literal_processor`
            method, unless subclassing the :class:`_types.UserDefinedType`
            class explicitly.

            To provide alternate behavior for
            :meth:`_types.TypeEngine.literal_processor`, implement a
            :class:`_types.TypeDecorator` class and provide an implementation
            of :meth:`_types.TypeDecorator.process_literal_param`.

            .. seealso::

                :ref:`types_typedecorator`


        N(
R"(RR+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytliteral_processor
s!c
Csd
S(s�Return a conversion function for processing bind values.

        Returns a callable which will receive a bind parameter value
        as the sole positional argument and will return a value to
        send to the DB-API.

        If processing is not necessary, the method should return ``None``.

        .. note::

            This method is only called relative to a **dialect specific type
            object**, which is often **private to a dialect in use** and is not
            the same type object as the public facing one, which means it's not
            feasible to subclass a :class:`.types.TypeEngine` class in order to
            provide an alternate :meth:`_types.TypeEngine.bind_processor`
            method, unless subclassing the :class:`_types.UserDefinedType`
            class explicitly.

            To provide alternate behavior for
            :meth:`_types.TypeEngine.bind_processor`, implement a
            :class:`_types.TypeDecorator` class and provide an implementation
            of :meth:`_types.TypeDecorator.process_bind_param`.

            .. seealso::

                :ref:`types_typedecorator`


        :param dialect: Dialect instance in use.

        N(
R"(RR+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytbind_processor1
s c
Csd
S(s
Return a conversion function for processing result row values.

        Returns a callable which will receive a result row column
        value as the sole positional argument and will return a value
        to return to the user.

        If processing is not necessary, the method should return ``None``.

        .. note::

            This method is only called relative to a **dialect specific type
            object**, which is often **private to a dialect in use** and is not
            the same type object as the public facing one, which means it's not
            feasible to subclass a :class:`.types.TypeEngine` class in order to
            provide an alternate :meth:`_types.TypeEngine.result_processor`
            method, unless subclassing the :class:`_types.UserDefinedType`
            class explicitly.

            To provide alternate behavior for
            :meth:`_types.TypeEngine.result_processor`, implement a
            :class:`_types.TypeDecorator` class and provide an implementation
            of :meth:`_types.TypeDecorator.process_result_value`.

            .. seealso::

                :ref:`types_typedecorator`

        :param dialect: Dialect instance in use.

        :param coltype: DBAPI coltype argument received in cursor.description.

        N(
R"(RR+tcoltype((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytresult_processorS
s!c
Csd
S(s<Given a SELECT column expression, return a wrapping SQL expression.

        This is typically a SQL function that wraps a column expression
        as rendered in the columns clause of a SELECT statement.
        It is used for special data types that require
        columns to be wrapped in some special database function in order
        to coerce the value before being sent back to the application.
        It is the SQL analogue of the :meth:`.TypeEngine.result_processor`
        method.

        This method is called during the **SQL compilation** phase of a
        statement, when rendering a SQL string. It is **not** called
        against specific values.

        .. note::

            This method is only called relative to a **dialect specific type
            object**, which is often **private to a dialect in use** and is not
            the same type object as the public facing one, which means it's not
            feasible to subclass a :class:`.types.TypeEngine` class in order to
            provide an alternate :meth:`_types.TypeEngine.column_expression`
            method, unless subclassing the :class:`_types.UserDefinedType`
            class explicitly.

            To provide alternate behavior for
            :meth:`_types.TypeEngine.column_expression`, implement a
            :class:`_types.TypeDecorator` class and provide an implementation
            of :meth:`_types.TypeDecorator.column_expression`.

            .. seealso::

                :ref:`types_typedecorator`


        .. seealso::

            :ref:`types_sql_value_processing`

        N(
R"(Rtcolexpr((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytcolumn_expressionv
s)c

Cs|jj
jtj
jk	S(
s�memoized boolean, check if column_expression is implemented.

        Allows the method to be skipped for the vast majority of expression
        types that don't use this feature.

        (R)R5t__code__R(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_has_column_expression�
s

c
Csd
S(s;Given a bind value (i.e. a :class:`.BindParameter` instance),
        return a SQL expression in its place.

        This is typically a SQL function that wraps the existing bound
        parameter within the statement.  It is used for special data types
        that require literals being wrapped in some special database function
        in order to coerce an application-level value into a database-specific
        format.  It is the SQL analogue of the
        :meth:`.TypeEngine.bind_processor` method.

        This method is called during the **SQL compilation** phase of a
        statement, when rendering a SQL string. It is **not** called
        against specific values.

        Note that this method, when implemented, should always return
        the exact same structure, without any conditional logic, as it
        may be used in an executemany() call against an arbitrary number
        of bound parameter sets.

        .. note::

            This method is only called relative to a **dialect specific type
            object**, which is often **private to a dialect in use** and is not
            the same type object as the public facing one, which means it's not
            feasible to subclass a :class:`.types.TypeEngine` class in order to
            provide an alternate :meth:`_types.TypeEngine.bind_expression`
            method, unless subclassing the :class:`_types.UserDefinedType`
            class explicitly.

            To provide alternate behavior for
            :meth:`_types.TypeEngine.bind_expression`, implement a
            :class:`_types.TypeDecorator` class and provide an implementation
            of :meth:`_types.TypeDecorator.bind_expression`.

            .. seealso::

                :ref:`types_typedecorator`

        .. seealso::

            :ref:`types_sql_value_processing`

        N(
R"(Rt	bindvalue((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytbind_expression�
s,c

Cstj
|tj�S(
s�memoized boolean, check if bind_expression is implemented.

        Allows the method to be skipped for the vast majority of expression
        types that don't use this feature.

        (Rtmethod_is_overriddenRR9(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_has_bind_expression�
s	c

Cs
t|�
S(
N(
tto_instance(
tcls_or_self((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_to_instance�
scCs
|
|kS(
s Compare two values for equality.((Rt
xt
y((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytcompare_values�
sc
Csd
S(s�Return the corresponding type object from the underlying DB-API, if
        any.

        This can be useful for calling ``setinputsizes()``, for example.

        N(
R"(Rtdbapi((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytget_dbapi_type�
sc


Cs
t��
d
S(sReturn the Python type object expected to be returned
        by instances of this type, if known.

        Basically, for those types which enforce a return type,
        or are known across the board to do such for all common
        DBAPIs (like ``int`` for example), will return that type.

        If a return type is not defined, raises
        ``NotImplementedError``.

        Note that any type also accommodates NULL in SQL which
        means you can also get back ``None`` from any type
        in practice.

        N(
tNotImplementedError(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytpython_type�
scCst|i
t
|
�
|6�S(
s6Produce a new type object that will utilize the given
        type when applied to the dialect of the given name.

        e.g.::

            from sqlalchemy.types import String
            from sqlalchemy.dialects import mysql

            s = String()

            s = s.with_variant(mysql.VARCHAR(collation='foo'), 'mysql')

        The construction of :meth:`.TypeEngine.with_variant` is always
        from the "fallback" type to that which is dialect specific.
        The returned type is an instance of :class:`.Variant`, which
        itself provides a :meth:`.Variant.with_variant`
        that can be called repeatedly.

        :param type\_: a :class:`.TypeEngine` that will be selected
         as a variant from the originating type, when a dialect
         of the given name is in use.
        :param dialect_name: base name of the dialect which uses
         this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)

        .. seealso::

            :ref:`types_with_variant` - illustrates the use of
            :meth:`_types.TypeEngine.with_variant`.

        (tVariantR<(Rttype_tdialect_name((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytwith_variant
sc
Cs|S(
s�adjust this type given a literal Python value that will be
        stored in a bound parameter.

        Used exclusively by _resolve_value_to_type().

        .. versionadded:: 1.4.30 or 2.0

        ((RR.((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_resolve_for_literal.s	c
Cs\d
}
xO|j
jD]:}|ttfkr/|
St|ttf�r|}
qqW|j
Sd
S(sRReturn a rudimental 'affinity' value expressing the general class
        of type.N(R"R)t__mro__RtUserDefinedTypet
issubclass(RR&t
t((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_type_affinity9s





c
Cs�d}
d}t
|ttf�s(|jSx�|jjD]�}|jdkr5t|t�r5|tk	r5|jddkr5|jj	�r�|r�|}q�|jj	�r�|
r�|}
q�q5q5W|
p�|p�t
jS(Nssqlalchemy.sql.sqltypesssqlalchemy.sql.type_apiit
_(ssqlalchemy.sql.sqltypesssqlalchemy.sql.type_api(R"t
isinstanceRRLR)RKRRMRtisuppertNULLTYPE(Rtbest_camelcasetbest_uppercaseRN((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_generic_type_affinityGs 


	


	

cCsX|
rE|jt
jkrEtd
j|jjd|jj�
�
�
ntj||j�S(s�
        Return an instance of the generic type corresponding to this type
        using heuristic rule. The method may be overridden if this
        heuristic rule is not sufficient.

        >>> from sqlalchemy.dialects.mysql import INTEGER
        >>> INTEGER(display_width=4).as_generic()
        Integer()

        >>> from sqlalchemy.dialects.mysql import NVARCHAR
        >>> NVARCHAR(length=100).as_generic()
        Unicode(length=100)

        .. versionadded:: 1.4.0b2


        .. seealso::

            :ref:`metadata_reflection_dbagnostic_types` - describes the
            use of :meth:`_types.TypeEngine.as_generic` in conjunction with
            the :meth:`_sql.DDLEvents.column_reflect` event, which is its
            intended use.

        s�Default TypeEngine.as_generic() heuristic method was unsuccessful for {}. A custom as_generic() method must be implemented for this type class.t
.(	RVRSR)RDtformatRRRtconstructor_copy(Rtallow_nulltype((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt
as_genericas

#cCs8y|
j|d
SWnt
k
r&


n
X|j|
�
d
S(sYReturn a dialect-specific implementation for this
        :class:`.TypeEngine`.

        timpl(t_type_memostKeyErrort
_dialect_info(RR+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytdialect_impl�s





cCs
|j|
�
S(
s�
Return the 'unwrapped' dialect impl for this type.

        For a type that applies wrapping logic (e.g. TypeDecorator), give
        us the real, actual dialect-level type that is used.

        This is used by TypeDecorator itself as well at least one case where
        dialects need to check that a particular specific dialect-level
        type is in use, within the :meth:`.DefaultDialect.set_input_sizes`
        method.

        (
R`(RR+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_unwrapped_dialect_impl�scCsUy|
j|d
SWnt
k
r&


n
X|j|
�
}|dj|
�
|d
<}|S(s:Return a dialect-specific literal processor for this type.tliteralR\(R]R^R_R0(RR+t
dtlp((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_cached_literal_processor�s





cCsUy|
j|d
SWnt
k
r&


n
X|j|
�
}|dj|
�
|d
<}|S(s7Return a dialect-specific bind processor for this type.tbindR\(R]R^R_R1(RR+Rctbp((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_cached_bind_processor�s





cCsXy|
j||SWnt
k
r&


n
X|j|
�
}|d
j|
|�||<}|S(s9Return a dialect-specific result processor for this type.R\(R]R^R_R3(RR+R2Rctrp((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_cached_result_processor�s




cCsXy|
j||SWnt
k
r&


n
X|j|
�
}|d
}||�
||<}|S(NR\(R]R^R_(RR+tkeytfnRcR\tresult((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_cached_custom_processor�s








cCs||
jkr|
j|S|j
|
�
}||krM|jt|�
�
}n||k	s_t�
i
|d
6|
j|<}|SdS(s�Return a dialect-specific registry which
        caches a dialect-specific implementation, bind processing
        function, and one or more result processing functions.R\N(R]t_gen_dialect_implR(R
tAssertionError(RR+R\Rc((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR_�s




cCs
|
j|�
S(
N(
ttype_descriptor(RR+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRo�s
c
s6tj
�j�
}
�jf
t�f
d
�|
D�
�
S(Nc
3sz|]p}
|
�jkr|
j
d�
r�j|
d
k	r|
t�j|
t�rd�j|
jn
�j|
fV
qd
S(RPN(t__dict__t
startswithR"RQRt_static_cache_key(t.0t
k(
R(sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pys	<genexpr>�s


(Rtget_cls_kwargsR)ttuple(Rtnames((
RsH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRt�s

cKstj
||
|�S(
s�Produce an "adapted" form of this type, given an "impl" class
        to work with.

        This method is used internally to associate generic
        types with "implementation" types that are specific to a particular
        dialect.
        (RRY(RtclsR*((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR(�scCs6t|�
}|t
ks*|j|jkr.|S|Sd
S(soSuggest a type for a 'coerced' Python value in an expression.

        Given an operator and value, gives the type a chance
        to return a type which the value should be coerced into.

        The default behavior here is conservative; if the right-hand
        side is already coerced into a SQL type based on its
        Python type, it is usually left alone.

        End-user functionality extension here should generally be via
        :class:`.TypeDecorator`, which provides more liberal behavior in that
        it defaults to coercing the other side of the expression into this
        type, thus applying special Python conversions above and beyond those
        needed by the DBAPI to both ides. It also provides the public method
        :meth:`.TypeDecorator.coerce_compared_value` which is intended for
        end-user customization of this behavior.

        N(t_resolve_value_to_typeRSRO(RRR.t
_coerced_type((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytcoerce_compared_values

cCs|j|
jkS(
N(
RO(RR((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_compare_type_affinity s
cCs%|
s|j�}
n|
j
j|�
S(
s�Produce a string-compiled form of this :class:`.TypeEngine`.

        When called with no arguments, uses a "default" dialect
        to produce a string result.

        :param dialect: a :class:`.Dialect` instance.

        (t_default_dialectt
type_compilertprocess(RR+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytcompile#s
ssqlalchemy.engine.defaultc

Cstj
j}
|
j�S(
N(RRtengine_defaulttStrCompileDialect(Rtdefault((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR4s
c

Cs9tj
r%t|j��
jd
d�St|j��
SdS(Ntasciitbackslashreplace(Rtpy2ktunicodeR�tencodetstr(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt__str__9s
	


c

Cs
tj
|�
S(
N(Rtgeneric_repr(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt__repr__As
N(<RRR Rt
_sqla_typetFalset_isnullt_is_tuple_typet_is_table_valuet	_is_arrayt_is_type_decoratorRtColumnOperatorsRthashabletcomparator_factoryR"tsort_key_functionR%R'R$R-R/R0R1R3R5Rtmemoized_propertyR7R9R;tstaticmethodR>RARCtpropertyRERIRJRORVR[R`RaReRhRjRnR_RoRtR(R}R~R�R#RR�R�(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR!s`





B
	4				#	"	#	+	.				!	(				
					
			tVisitableCheckKWArgc
BseZ
RS((RR(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�Es
tExternalTypecBs#eZ
dZdZed
��
ZRS(s�
mixin that defines attributes and behaviors specific to third-party
    datatypes.

    "Third party" refers to datatypes that are defined outside the scope
    of SQLAlchemy within either end-user application code or within
    external extensions to SQLAlchemy.

    Subclasses currently include :class:`.TypeDecorator` and
    :class:`.UserDefinedType`.

    .. versionadded:: 1.4.28

    c
Cs�|jj
jd
d�}
|
dkry|jjjt�
}|jjt|dd�}tj	d|j
|fdd�


n|
tkr�tt|�j
StS(Ntcache_oki
isZ
%s %r will not produce a cache key because the ``cache_ok`` attribute is not set to True.  This can have significant performance implications including some performance degradations in comparison to prior SQLAlchemy versions.  Set this attribute to True if this type object's state is safe to use in a cache key, or False to disable this warning.tcodetcprf(R)RrtgetR"RKtindexR�tmaxRtwarnRRtsuperRtR(RR�tsubtype_idxtsubtype((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRt�s





N(RRR R"R�R�Rt(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�Is
�RLc
Bs#eZ
dZd
ZdZd�ZRS(s�	Base for user defined types.

    This should be the base of new types.  Note that
    for most cases, :class:`.TypeDecorator` is probably
    more appropriate::

      import sqlalchemy.types as types

      class MyType(types.UserDefinedType):
          cache_ok = True

          def __init__(self, precision = 8):
              self.precision = precision

          def get_col_spec(self, **kw):
              return "MYTYPE(%s)" % self.precision

          def bind_processor(self, dialect):
              def process(value):
                  return value
              return process

          def result_processor(self, dialect, coltype):
              def process(value):
                  return value
              return process

    Once the type is made, it's immediately usable::

      table = Table('foo', metadata_obj,
          Column('id', Integer, primary_key=True),
          Column('data', MyType(16))
          )

    The ``get_col_spec()`` method will in most cases receive a keyword
    argument ``type_expression`` which refers to the owning expression
    of the type as being compiled, such as a :class:`_schema.Column` or
    :func:`.cast` construct.  This keyword is only sent if the method
    accepts keyword arguments (e.g. ``**kw``) in its argument signature;
    introspection is used to check for this in order to support legacy
    forms of this function.

    .. versionadded:: 1.0.0 the owning expression is passed to
       the ``get_col_spec()`` method via the keyword argument
       ``type_expression``, if it receives ``**kw`` in its signature.

    The :attr:`.UserDefinedType.cache_ok` class-level flag indicates if this
    custom :class:`.UserDefinedType` is safe to be used as part of a cache key.
    This flag defaults to ``None`` which will initially generate a warning
    when the SQL compiler attempts to generate a cache key for a statement
    that uses this type.  If the :class:`.UserDefinedType` is not guaranteed
    to produce the same bind/result behavior and SQL generation
    every time, this flag should be set to ``False``; otherwise if the
    class produces the same behavior each time, it may be set to ``True``.
    See :attr:`.UserDefinedType.cache_ok` for further notes on how this works.

    .. versionadded:: 1.4.28 Generalized the :attr:`.ExternalType.cache_ok`
       flag so that it is available for both :class:`.TypeDecorator` as well
       as :class:`.UserDefinedType`.

    tuser_definedtget_col_specc
Cs|S(
s�
Suggest a type for a 'coerced' Python value in an expression.

        Default behavior for :class:`.UserDefinedType` is the
        same as that of :class:`.TypeDecorator`; by default it returns
        ``self``, assuming the compared value should be coerced into
        the same type as this one.  See
        :meth:`.TypeDecorator.coerce_compared_value` for more detail.

        ((RRR.((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR}>s(RRR t__visit_name__tensure_kwargR}(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRL�s?tEmulatedc
Bs eZ
dZd
�Zd�ZRS(s�Mixin for base types that emulate the behavior of a DB-native type.

    An :class:`.Emulated` type will use an available database type
    in conjunction with Python-side routines and/or database constraints
    in order to approximate the behavior of a database type that is provided
    natively by some backends.  When a native-providing backend is in
    use, the native version of the type is used.  This native version
    should include the :class:`.NativeForEmulated` mixin to allow it to be
    distinguished from :class:`.Emulated`.

    Current examples of :class:`.Emulated` are:  :class:`.Interval`,
    :class:`.Enum`, :class:`.Boolean`.

    .. versionadded:: 1.2.0b3

    cKstt
|�j|
|�
S(
s
Given an impl class, adapt this type to the impl assuming
        "emulated".

        The impl should also be an "emulated" version of this type,
        most likely the same class as this type itself.

        e.g.: sqltypes.Enum adapts to the Enum class.

        (R�R�R((RtimpltypeR*((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytadapt_to_emulated^s
cKszt|
d
�r;|j
r(|
j||�
S|
j||�
Sn;t|
|j�r]|j|
|�
Stt|�j	|
|�
SdS(Ntadapt_emulated_to_native(
thasattrtnativeR�tadapt_native_to_emulatedRMR)R�R�R�R((RR�R*((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR(js

	
(RRR R�R((((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�Ls	tNativeForEmulatedcBs,eZ
dZed
��
Zed��
ZRS(sgIndicates DB-native types supported by an :class:`.Emulated` type.

    .. versionadded:: 1.2.0b3

    cKs|
j}|
j
||�
S(
sZGiven an impl, adapt this type's class to the impl assuming
        "emulated".


        (R)R((RzR\R*R�((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s	
cKs
||�S(
s
Given an impl, adapt this type's class to the impl assuming
        "native".

        The impl will be an :class:`.Emulated` class but not a
        :class:`.NativeForEmulated`.

        e.g.: postgresql.ENUM produces a type given an Enum instance.

        ((RzR\R*((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s(RRR tclassmethodR�R�(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�|s
t
TypeDecoratorcBs�
eZ
dZd
ZeZd�Zejf
Z	de
jf
d��YZed��
Z
d�Zed��
Zed�
Zd	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zejd��
Zejd��
Zd�Zd�Zejd��
Zd�Z ejd��
Z!d�Z"ejd��
Z#d�Z$d�Z%d�Z&d�Z'd�Z(ed��
Z)d �Z*RS(!s�Allows the creation of types which add additional functionality
    to an existing type.

    This method is preferred to direct subclassing of SQLAlchemy's
    built-in types as it ensures that all required functionality of
    the underlying type is kept in place.

    Typical usage::

      import sqlalchemy.types as types

      class MyType(types.TypeDecorator):
          '''Prefixes Unicode values with "PREFIX:" on the way in and
          strips it off on the way out.
          '''

          impl = types.Unicode

          cache_ok = True

          def process_bind_param(self, value, dialect):
              return "PREFIX:" + value

          def process_result_value(self, value, dialect):
              return value[7:]

          def copy(self, **kw):
              return MyType(self.impl.length)

    The class-level ``impl`` attribute is required, and can reference any
    :class:`.TypeEngine` class.  Alternatively, the :meth:`load_dialect_impl`
    method can be used to provide different type classes based on the dialect
    given; in this case, the ``impl`` variable can reference
    ``TypeEngine`` as a placeholder.

    The :attr:`.TypeDecorator.cache_ok` class-level flag indicates if this
    custom :class:`.TypeDecorator` is safe to be used as part of a cache key.
    This flag defaults to ``None`` which will initially generate a warning
    when the SQL compiler attempts to generate a cache key for a statement
    that uses this type.  If the :class:`.TypeDecorator` is not guaranteed
    to produce the same bind/result behavior and SQL generation
    every time, this flag should be set to ``False``; otherwise if the
    class produces the same behavior each time, it may be set to ``True``.
    See :attr:`.TypeDecorator.cache_ok` for further notes on how this works.

    Types that receive a Python type that isn't similar to the ultimate type
    used may want to define the :meth:`TypeDecorator.coerce_compared_value`
    method. This is used to give the expression system a hint when coercing
    Python objects into bind parameters within expressions. Consider this
    expression::

        mytable.c.somecol + datetime.date(2009, 5, 15)

    Above, if "somecol" is an ``Integer`` variant, it makes sense that
    we're doing date arithmetic, where above is usually interpreted
    by databases as adding a number of days to the given date.
    The expression system does the right thing by not attempting to
    coerce the "date()" value into an integer-oriented bind parameter.

    However, in the case of ``TypeDecorator``, we are usually changing an
    incoming Python type to something new - ``TypeDecorator`` by default will
    "coerce" the non-typed side to be the same type as itself. Such as below,
    we define an "epoch" type that stores a date value as an integer::

        class MyEpochType(types.TypeDecorator):
            impl = types.Integer

            epoch = datetime.date(1970, 1, 1)

            def process_bind_param(self, value, dialect):
                return (value - self.epoch).days

            def process_result_value(self, value, dialect):
                return self.epoch + timedelta(days=value)

    Our expression of ``somecol + date`` with the above type will coerce the
    "date" on the right side to also be treated as ``MyEpochType``.

    This behavior can be overridden via the
    :meth:`~TypeDecorator.coerce_compared_value` method, which returns a type
    that should be used for the value of the expression. Below we set it such
    that an integer value will be treated as an ``Integer``, and any other
    value is assumed to be a date and will be treated as a ``MyEpochType``::

        def coerce_compared_value(self, op, value):
            if isinstance(value, int):
                return Integer()
            else:
                return self

    .. warning::

       Note that the **behavior of coerce_compared_value is not inherited
       by default from that of the base type**.
       If the :class:`.TypeDecorator` is augmenting a
       type that requires special logic for certain types of operators,
       this method **must** be overridden.  A key example is when decorating
       the :class:`_postgresql.JSON` and :class:`_postgresql.JSONB` types;
       the default rules of :meth:`.TypeEngine.coerce_compared_value` should
       be used in order to deal with operators like index operations::

            from sqlalchemy import JSON
            from sqlalchemy import TypeDecorator

            class MyJsonType(TypeDecorator):
                impl = JSON

                cache_ok = True

                def coerce_compared_value(self, op, value):
                    return self.impl.coerce_compared_value(op, value)

       Without the above step, index operations such as ``mycol['foo']``
       will cause the index value ``'foo'`` to be JSON encoded.

       Similarly, when working with the :class:`.ARRAY` datatype, the
       type coercion for index operations (e.g. ``mycol[5]``) is also
       handled by :meth:`.TypeDecorator.coerce_compared_value`, where
       again a simple override is sufficient unless special rules are needed
       for particular operators::

            from sqlalchemy import ARRAY
            from sqlalchemy import TypeDecorator

            class MyArrayType(TypeDecorator):
                impl = ARRAY

                cache_ok = True

                def coerce_compared_value(self, op, value):
                    return self.impl.coerce_compared_value(op, value)


    ttype_decoratorc
Os@t|j
d
�s!td�
�
nt|j
j|
|�
|_dS(s�Construct a :class:`.TypeDecorator`.

        Arguments sent here are passed to the constructor
        of the class assigned to the ``impl`` class level attribute,
        assuming the ``impl`` is a callable, and the resulting
        object is assigned to the ``self.impl`` instance attribute
        (thus overriding the class attribute of the same name).

        If the class level ``impl`` is not a callable (the unusual case),
        it will be assigned to the same instance attribute 'as-is',
        ignoring those arguments passed to the constructor.

        Subclasses can override this to customize the generation
        of ``self.impl`` entirely.

        R\suTypeDecorator implementations require a class-level variable 'impl' which refers to the class of type being decoratedN(R�R)RpR<R\(RtargsR((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR
's

Rc
Bs&eZ
dZdZd
�Zd�ZRS(s�A :class:`.TypeEngine.Comparator` that is specific to
        :class:`.TypeDecorator`.

        User-defined :class:`.TypeDecorator` classes should not typically
        need to modify this.


        cOs2|jj
j|d
<ttj|�j|
||�
S(Nt_python_is_types(R	R
tcoerce_to_is_typesR�R�RR(RRRR((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR_s


cKs2|jj
j|d
<ttj|�j|
||�S(NR�(R	R
R�R�R�RR(RRRR((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRes


((RRR R!RR(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRSs	c

CsEtj
|jjjkr"|jjStd
tj
|jjfi�SdS(NtTDComparator(R�RR\R�RKR
(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�ks




cCs~|
j|�
}||k	r|S|j
|
�
j|
�
}|j�}t||j�sqtd
||jf�
�
n||_|S(s
        #todo
        saType object %s does not properly implement the copy() method, it must return an object of type %s(Rqtload_dialect_implR`R$RQR)RpR\(RR+tadaptedttypedescttt((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRovs





	
c


Cs
|jj
S(
s
        #todo
        (R\RO(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRO�scKsOtt
|�j|
�

|rKt|jt�rK|jj|
d
t|�


ndS(sSupport SchemaEventTargettouterN(R�R�t_set_parentRQR\R
R�(RtcolumnR�R*((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s
cCsEtt
|�j|
d
t�


t|jt�rA|jj|
�

ndS(sSupport SchemaEventTargetR�N(R�R�t_set_parent_with_dispatchRRQR\R
(Rtparent((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s


cCs9|
j|�
}t
|t|�
�s(|S|j|
�
Sd
S(ss
Return a dialect-specific :class:`.TypeEngine` instance
        for this :class:`.TypeDecorator`.

        In most cases this returns a dialect-adapted form of
        the :class:`.TypeEngine` type represented by ``self.impl``.
        Makes usage of :meth:`dialect_impl`.
        Behavior can be customized here by overriding
        :meth:`load_dialect_impl`.

        N(RqRQR
R�(RR+R�((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyttype_engine�s

c
Cs|jS(
s�
Return a :class:`.TypeEngine` object corresponding to a dialect.

        This is an end-user override hook that can be used to provide
        differing types depending on the given dialect.  It is used
        by the :class:`.TypeDecorator` implementation of :meth:`type_engine`
        to help determine what type should ultimately be returned
        for a given :class:`.TypeDecorator`.

        By default returns ``self.impl``.

        (
R\(RR+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��scCs?|j|
�
}t
||j�r7|j|
�
j|
�
S|Sd
S(s�Return the 'unwrapped' dialect impl for this type.

        This is used by the :meth:`.DefaultDialect.set_input_sizes`
        method.

        N(R`RQR)R�(RR+R&((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRa�s	
cCst|j
|
�S(
sMProxy all other undefined accessors to the underlying
        implementation.(tgetattrR\(RRk((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt__getattr__�sc
Cs
t��
d
S(s�Receive a literal parameter value to be rendered inline within
        a statement.

        .. note::

            This method is called during the **SQL compilation** phase of a
            statement, when rendering a SQL string. Unlike other SQL
            compilation methods, it is passed a specific Python value to be
            rendered as a string. However it should not be confused with the
            :meth:`_types.TypeDecorator.process_bind_param` method, which is
            the more typical method that processes the actual value passed to a
            particular parameter at statement execution time.

        Custom subclasses of :class:`_types.TypeDecorator` should override
        this method to provide custom behaviors for incoming data values
        that are in the special case of being rendered as literals.

        The returned string will be rendered into the output string.

        N(
RD(RR.R+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytprocess_literal_param�sc
Cs
t��
d
S(s|Receive a bound parameter value to be converted.

        Custom subclasses of :class:`_types.TypeDecorator` should override
        this method to provide custom behaviors for incoming data values.
        This method is called at **statement execution time** and is passed
        the literal Python data value which is to be associated with a bound
        parameter in the statement.

        The operation could be anything desired to perform custom
        behavior, such as transforming or serializing data.
        This could also be used as a hook for validating logic.

        :param value: Data to operate upon, of any type expected by
         this method in the subclass.  Can be ``None``.
        :param dialect: the :class:`.Dialect` in use.

        .. seealso::

            :ref:`types_typedecorator`

            :meth:`_types.TypeDecorator.process_result_value`

        N(
RD(RR.R+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytprocess_bind_param�sc
Cs
t��
d
S(s[Receive a result-row column value to be converted.

        Custom subclasses of :class:`_types.TypeDecorator` should override
        this method to provide custom behaviors for data values
        being received in result rows coming from the database.
        This method is called at **result fetching time** and is passed
        the literal Python data value that's extracted from a database result
        row.

        The operation could be anything desired to perform custom
        behavior, such as transforming or deserializing data.

        :param value: Data to operate upon, of any type expected by
         this method in the subclass.  Can be ``None``.
        :param dialect: the :class:`.Dialect` in use.

        .. seealso::

            :ref:`types_typedecorator`

            :meth:`_types.TypeDecorator.process_bind_param`


        N(
RD(RR.R+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pytprocess_result_value
sc

Cstj
|tj�S(
s�memoized boolean, check if process_bind_param is implemented.

        Allows the base process_bind_param to raise
        NotImplementedError without needing to test an expensive
        exception throw.

        (RR:R�R�(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_has_bind_processor)s

c

Cstj
|tj�S(
s@memoized boolean, check if process_literal_param is implemented.(RR:R�R�(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_has_literal_processor7s
cs�|jr|j
�n|jr*|j�nd��r||jj��
�
�
rf��
�fd
�}n��fd�}|S|jj��
SdS(sfProvide a literal processing function for the given
        :class:`.Dialect`.

        This is the method that fulfills the :class:`.TypeEngine`
        contract for literal value conversion which normally occurs via
        the :meth:`_types.TypeEngine.literal_processor` method.

        .. note::

            User-defined subclasses of :class:`_types.TypeDecorator` should
            **not** implement this method, and should instead implement
            :meth:`_types.TypeDecorator.process_literal_param` so that the
            "inner" processing provided by the implementing type is maintained.

        c

s�
�|���
S(
N((
R.(R+timpl_processort
process_param(sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�^s
c

s
�
|��S(
N((
R.(R+R�(sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�cs
N(R�R�R�R�R"R\R0(RR+R�((R+R�R�sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR0?s	

	

csl|jrX|j
�|jj��
�
�
rB��
�fd
�}n��fd�}|S|jj��
SdS(s�Provide a bound value processing function for the
        given :class:`.Dialect`.

        This is the method that fulfills the :class:`.TypeEngine`
        contract for bound value conversion which normally occurs via
        the :meth:`_types.TypeEngine.bind_processor` method.

        .. note::

            User-defined subclasses of :class:`_types.TypeDecorator` should
            **not** implement this method, and should instead implement
            :meth:`_types.TypeDecorator.process_bind_param` so that the "inner"
            processing provided by the implementing type is maintained.

        :param dialect: Dialect instance in use.

        c

s�
�|���
S(
N((
R.(R+R�R�(sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s
c

s
�
|��S(
N((
R.(R+R�(sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s
N(R�R�R\R1(RR+R�((R+R�R�sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR1js	
	

c

Cstj
|tj�S(
s�memoized boolean, check if process_result_value is implemented.

        Allows the base process_result_value to raise
        NotImplementedError without needing to test an expensive
        exception throw.

        (RR:R�R�(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt_has_result_processor�s

csr|jr[|j
�|jj�|��
�
rE��
�fd
�}n��fd�}|S|jj�|�SdS(s�Provide a result value processing function for the given
        :class:`.Dialect`.

        This is the method that fulfills the :class:`.TypeEngine`
        contract for bound value conversion which normally occurs via
        the :meth:`_types.TypeEngine.result_processor` method.

        .. note::

            User-defined subclasses of :class:`_types.TypeDecorator` should
            **not** implement this method, and should instead implement
            :meth:`_types.TypeDecorator.process_result_value` so that the
            "inner" processing provided by the implementing type is maintained.

        :param dialect: Dialect instance in use.
        :param coltype: A SQLAlchemy data type

        c

s��
|�
��S(
N((
R.(R+R�t
process_value(sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s
c

s
�
|��S(
N((
R.(R+R�(sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s
N(R�R�R\R3(RR+R2R�((R+R�R�sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR3�s	
	

c

Cstj
|tj�p|jjS(
N(RR:R�R9R\R;(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR;�s
cCs|jj
|
�
S(
s`Given a bind value (i.e. a :class:`.BindParameter` instance),
        return a SQL expression which will typically wrap the given parameter.

        .. note::

            This method is called during the **SQL compilation** phase of a
            statement, when rendering a SQL string. It is **not** necessarily
            called against specific values, and should not be confused with the
            :meth:`_types.TypeDecorator.process_bind_param` method, which is
            the more typical method that processes the actual value passed to a
            particular parameter at statement execution time.

        Subclasses of :class:`_types.TypeDecorator` can override this method
        to provide custom bind expression behavior for the type.  This
        implementation will **replace** that of the underlying implementation
        type.

        (R\R9(Rt	bindparam((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR9�sc

Cstj
|tj�p|jjS(
s�memoized boolean, check if column_expression is implemented.

        Allows the method to be skipped for the vast majority of expression
        types that don't use this feature.

        (RR:R�R5R\R7(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR7�s

cCs|jj
|
�
S(
s�Given a SELECT column expression, return a wrapping SQL expression.

        .. note::

            This method is called during the **SQL compilation** phase of a
            statement, when rendering a SQL string. It is **not** called
            against specific values, and should not be confused with the
            :meth:`_types.TypeDecorator.process_result_value` method, which is
            the more typical method that processes the actual value returned
            in a result row subsequent to statement execution time.

        Subclasses of :class:`_types.TypeDecorator` can override this method
        to provide custom column expresion behavior for the type.  This
        implementation will **replace** that of the underlying implementation
        type.

        See the description of :meth:`_types.TypeEngine.column_expression`
        for a complete description of the method's use.

        (R\R5(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR5�sc
Cs|S(
s}Suggest a type for a 'coerced' Python value in an expression.

        By default, returns self.   This method is called by
        the expression system when an object using this type is
        on the left or right side of an expression against a plain Python
        object which does not yet have a SQLAlchemy type assigned::

            expr = table.c.somecolumn + 35

        Where above, if ``somecolumn`` uses this type, this method will
        be called with the value ``operator.add``
        and ``35``.  The return value is whatever SQLAlchemy type should
        be used for ``35`` for this particular operation.

        ((RRR.((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR}sc
Ks,|jj
|j�
}|jj|j�

|S(
sG
Produce a copy of this :class:`.TypeDecorator` instance.

        This is a shallow copy and is provided to fulfill part of
        the :class:`.TypeEngine` contract.  It usually does not
        need to be overridden unless the user-defined :class:`.TypeDecorator`
        has local state that should be deep-copied.

        (R)t__new__Rrtupdate(RR*tinstance((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR$s


cCs|jj
|
�
S(
s�Return the DBAPI type object represented by this
        :class:`.TypeDecorator`.

        By default this calls upon :meth:`.TypeEngine.get_dbapi_type` of the
        underlying "impl".
        (R\RC(RRB((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRC"scCs|jj
|
|�S(
s�
Given two values, compare them for equality.

        By default this calls upon :meth:`.TypeEngine.compare_values`
        of the underlying "impl", which in turn usually
        uses the Python equals operator ``==``.

        This function is used by the ORM to compare
        an original-loaded value with an intercepted
        "changed" value, to determine if a net change
        has occurred.

        (R\RA(RR?R@((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRA+s
c


Cs
|jj
S(
N(R\R�(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�:sc

Cstj
|d
|j�

S(Nt
to_inspect(RR�R\(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�>s
(+RRR R�RR�R
RtNoneTypeR�RRR�R�RoROR�R�R�R�R�RaR�R�R�R�R�R�R�R0R1R�R3R;R9R7R5R}R$RCRAR�R�(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��sD�			
								+	#	$							RFcBsneZ
dZeZd
�Zejd��
Zd�Z	d�Z
ed�
Zd�Z
d�Zed��
ZRS(	s
A wrapping type that selects among a variety of
    implementations based on dialect in use.

    The :class:`.Variant` type is typically constructed
    using the :meth:`.TypeEngine.with_variant` method.

    .. seealso:: :meth:`.TypeEngine.with_variant` for an example of use.

    cCs|
|_||_
d
S(s�Construct a new :class:`.Variant`.

        :param base: the base 'fallback' type
        :param mapping: dictionary of string dialect names to
          :class:`.TypeEngine` instances.

        N(R\tmapping(RtbaseR�((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR
Os	
c

s9�jf
�j
jt�f
d
�t�j�
D�
�
fS(Nc
3s%|]}
|
�j|
j
fV
qdS(
N(R�Rt(RuRk(
R(sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pys	<genexpr>`s
(R)R\RtRxtsortedR�(
R((
RsH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRtZs
	
	


cCs0|jj
|
|�}||jkr(|S|SdS(
N(R\R}(RtoperatorR.Rm((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR}es


cCs+|
j|j
kr |j
|
jS|jSdS(
N(tnameR�R\(RR+((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�ls

cKsht|j
t�r(|j
j|
|�

nx9|jj�D](}t|t�r8|j|
|�

q8q8Wd
S(sSupport SchemaEventTargetN(RQR\R
R�R�tvalues(RR�R�R*R\((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�rs




cCsbt|j
t�r%|j
j|
�

nx6|jj�D]%}t|t�r5|j|
�

q5q5Wd
S(sSupport SchemaEventTargetN(RQR\R
R�R�R�(RR�R\((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�{s




cCsN||jkr%t
jd
|�
�
n|jj�}|
||<t|j|�S(s�
Return a new :class:`.Variant` which adds the given
        type + dialect name to the mapping, in addition to the
        mapping present in this :class:`.Variant`.

        :param type\_: a :class:`.TypeEngine` that will be selected
         as a variant from the originating type, when a dialect
         of the given name is in use.
        :param dialect_name: base name of the dialect which uses
         this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.)

        s?Dialect '%s' is already present in the mapping for this Variant(R�Rt
ArgumentErrorR$RFR\(RRGRHR�((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRI�s







c


Cs
|jj
S(
s5express comparison behavior in terms of the base type(R\R�(
R((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR��s(RRR RR�R
RR�RtR}R�R�R�R�RIR�R�(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyRFBs								cCs&|
dkr|j
S|
j}||�
S(
N(R"t
comparatorR�(t
expressionRGR�((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR�s
	
c
Os1|dkrt
St|�
r)||
|�S|SdS(
N(R"RStcallable(ttypeobjtargR*((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyR<�s




cCs�t|t
�r|�}nxB|jjd
d!D])}y|
|}PWq/tk
rW


q/Xq/W|St|j|�rv|S|j|�
S(Nii����(RQR
R)RKR^RMR((R�tcolspecsRNR�((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt
adapt_type�s











N($R tRR�R
t
traversalsRtvisitorsRRRRR"tBOOLEANTYPEtINTEGERTYPERStNUMERICTYPEt
STRINGTYPEt	MATCHTYPEt	INDEXABLEt
TABLEVALUER{RtEnsureKWArgTypeR�tobjectR�twith_metaclassRLR�R�R�RFRR<R�(((sH/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/type_api.pyt<module>
sB













���'�
"R0���^