Module Expr Str ImportFrom alias alias ImportFrom alias ImportFrom alias Assign NameStore NameLoad Assign NameStore NameLoad Assign NameStore NameLoad Assign NameStore NameLoad ClassDef bases NameLoad body Expr Str Assign NameStore NameLoad Assign NameStore NameLoad ClassDef bases AttributeLoad NameLoad attr body Expr Str FunctionDef arguments args NameParam NameParam defaults body Assign AttributeStore NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Return TupleLoad NameLoad TupleLoad AttributeLoad NameLoad attr decorator_list decorator_list Assign NameStore NameLoad Expr Str Assign NameStore NameLoad Expr Str FunctionDef arguments args NameParam NameParam defaults body Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return CompareIsNot AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr AttributeLoad AttributeLoad NameLoad attr attr decorator_list AttributeLoad NameLoad attr FunctionDef arguments args NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return CompareIsNot AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr AttributeLoad AttributeLoad NameLoad attr attr decorator_list AttributeLoad NameLoad attr FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Return CompareEq NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Raise Call NameLoad decorator_list NameLoad FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Return Call NameLoad NameLoad Dict NameLoad Call NameLoad NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Assign NameStore NameLoad For NameStore AttributeLoad AttributeLoad NameLoad attr attr body If CompareIn NameLoad TupleLoad NameLoad NameLoad body Return NameLoad orelse If Call NameLoad NameLoad TupleLoad NameLoad NameLoad body Assign NameStore NameLoad orelse Return AttributeLoad NameLoad attr decorator_list AttributeLoad NameLoad attr FunctionDef arguments args NameParam NameParam defaults body Expr Str TryExcept body Return SubscriptLoad SubscriptLoad AttributeLoad NameLoad attr Index NameLoad Index Str handlers ExceptHandler type NameLoad body Return SubscriptLoad Call AttributeLoad NameLoad attr NameLoad Index Str decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str TryExcept body Return SubscriptLoad SubscriptLoad AttributeLoad NameLoad attr Index NameLoad Index Str handlers ExceptHandler type NameLoad body Assign NameStore Call AttributeLoad NameLoad attr NameLoad Assign SubscriptStore NameLoad Index Str NameStore Call AttributeLoad SubscriptLoad NameLoad Index Str attr NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str TryExcept body Return SubscriptLoad SubscriptLoad AttributeLoad NameLoad attr Index NameLoad Index Str handlers ExceptHandler type NameLoad body Assign NameStore Call AttributeLoad NameLoad attr NameLoad Assign SubscriptStore NameLoad Index Str NameStore Call AttributeLoad SubscriptLoad NameLoad Index Str attr NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str TryExcept body Return SubscriptLoad SubscriptLoad AttributeLoad NameLoad attr Index NameLoad Index NameLoad handlers ExceptHandler type NameLoad body Assign NameStore Call AttributeLoad NameLoad attr NameLoad Assign SubscriptStore NameLoad Index NameLoad NameStore Call AttributeLoad SubscriptLoad NameLoad Index Str attr NameLoad NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str If CompareIn NameLoad AttributeLoad NameLoad attr body Return SubscriptLoad AttributeLoad NameLoad attr Index NameLoad orelse Assign NameStore Call AttributeLoad NameLoad attr NameLoad If CompareIs NameLoad NameLoad body Assign NameStore Call AttributeLoad NameLoad attr Call NameLoad NameLoad Assert CompareIsNot NameLoad NameLoad Assign SubscriptStore AttributeLoad NameLoad attr Index NameLoad NameStore Dict Str NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Return Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults kwarg body Expr Str Return Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Assign NameStore Call AttributeLoad NameLoad attr Call NameLoad NameLoad NameLoad If BoolOpOr CompareIs NameLoad NameLoad CompareIs AttributeLoad NameLoad attr AttributeLoad NameLoad attr body Return NameLoad orelse Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Return CompareIs AttributeLoad NameLoad attr AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam NameParam defaults NameLoad body Expr Str If UnaryOpNot NameLoad body Assign NameStore Call AttributeLoad NameLoad attr Return Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body If Call AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr Str body Assign NameStore SubscriptLoad Call AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr Str Slice Num Num Assign NameStore Call AttributeLoad Str attr NameLoad Return Call AttributeLoad Call NameLoad AttributeLoad Call NameLoad NameLoad attr SubscriptLoad NameLoad Index Num attr orelse Return Call AttributeLoad NameLoad attr decorator_list Call AttributeLoad NameLoad attr Str FunctionDef arguments args NameParam defaults body If AttributeLoad NameLoad attr body Return Call AttributeLoad Call NameLoad Call AttributeLoad NameLoad attr attr Str Str orelse Return Call NameLoad Call AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam defaults body Return Call AttributeLoad NameLoad attr NameLoad decorator_list decorator_list ClassDef bases NameLoad body Expr Str Assign NameStore Str ClassDef bases AttributeLoad NameLoad attr body FunctionDef arguments args NameParam NameParam NameParam defaults body If Call NameLoad AttributeLoad NameLoad attr Str body Expr Call AttributeLoad NameLoad attr Str Return TupleLoad Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad AttributeLoad NameLoad attr orelse Return TupleLoad NameLoad AttributeLoad NameLoad attr decorator_list decorator_list Assign NameStore NameLoad FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Return NameLoad decorator_list decorator_list ClassDef bases NameLoad body Expr Str Assign NameStore Str FunctionDef arguments args NameParam defaults vararg kwarg body Expr Str If UnaryOpNot Call NameLoad AttributeLoad NameLoad attr Str body Raise Call NameLoad Str Assign AttributeStore NameLoad attr Call NameLoad AttributeLoad AttributeLoad NameLoad attr attr NameLoad NameLoad decorator_list Assign NameStore TupleLoad AttributeLoad NameLoad attr Expr Str ClassDef bases AttributeLoad NameLoad attr body FunctionDef arguments args NameParam NameParam defaults vararg kwarg body Assign SubscriptStore NameLoad Index Str AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr Return Call AttributeLoad Call NameLoad AttributeLoad NameLoad attr NameLoad attr NameLoad NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults kwarg body Assign SubscriptStore NameLoad Index Str AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr Return Call AttributeLoad Call NameLoad AttributeLoad NameLoad attr NameLoad attr NameLoad NameLoad NameLoad decorator_list decorator_list FunctionDef arguments args NameParam defaults body Return Call NameLoad Str TupleLoad AttributeLoad NameLoad attr AttributeLoad AttributeLoad NameLoad attr attr Dict decorator_list NameLoad FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign NameStore Call AttributeLoad NameLoad attr NameLoad If CompareIsNot NameLoad NameLoad body Return NameLoad Assign NameStore Call AttributeLoad Call AttributeLoad NameLoad attr NameLoad attr NameLoad Assign NameStore Call AttributeLoad NameLoad attr If UnaryOpNot Call NameLoad NameLoad AttributeLoad NameLoad attr body Raise Call NameLoad BinOpMod Str TupleLoad NameLoad AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return AttributeLoad AttributeLoad NameLoad attr attr decorator_list NameLoad FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign NameStore Call AttributeLoad NameLoad attr NameLoad If UnaryOpNot Call NameLoad NameLoad Call NameLoad NameLoad body Return NameLoad orelse If Call NameLoad AttributeLoad NameLoad attr NameLoad body Return Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad orelse Return Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return Call NameLoad AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Raise Call NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Raise Call NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Raise Call NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return CompareIsNot AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr AttributeLoad AttributeLoad NameLoad attr attr decorator_list AttributeLoad NameLoad attr FunctionDef arguments args NameParam defaults body Expr Str Return CompareIsNot AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr AttributeLoad AttributeLoad NameLoad attr attr decorator_list AttributeLoad NameLoad attr FunctionDef arguments args NameParam NameParam defaults body Expr Str If AttributeLoad NameLoad attr body Assign NameStore AttributeLoad NameLoad attr orelse If AttributeLoad NameLoad attr body Assign NameStore AttributeLoad NameLoad attr orelse Assign NameStore NameLoad If NameLoad body Assign NameStore Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad If NameLoad body FunctionDef arguments args NameParam defaults body Return Call NameLoad Call NameLoad NameLoad NameLoad decorator_list orelse FunctionDef arguments args NameParam defaults body Return Call NameLoad NameLoad NameLoad decorator_list Return NameLoad orelse Return Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str If AttributeLoad NameLoad attr body Assign NameStore AttributeLoad NameLoad attr Assign NameStore Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad If NameLoad body FunctionDef arguments args NameParam defaults body Return Call NameLoad Call NameLoad NameLoad NameLoad decorator_list orelse FunctionDef arguments args NameParam defaults body Return Call NameLoad NameLoad NameLoad decorator_list Return NameLoad orelse Return Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return CompareIsNot AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr AttributeLoad AttributeLoad NameLoad attr attr decorator_list AttributeLoad NameLoad attr FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str If AttributeLoad NameLoad attr body Assign NameStore AttributeLoad NameLoad attr Assign NameStore Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad NameLoad If NameLoad body FunctionDef arguments args NameParam defaults body Return Call NameLoad Call NameLoad NameLoad NameLoad decorator_list orelse FunctionDef arguments args NameParam defaults body Return Call NameLoad NameLoad NameLoad decorator_list Return NameLoad orelse Return Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Assign NameStore Call AttributeLoad AttributeLoad NameLoad attr attr AttributeLoad NameLoad attr Expr Call AttributeLoad AttributeLoad NameLoad attr attr AttributeLoad NameLoad attr Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Return Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad NameLoad decorator_list FunctionDef arguments args NameParam defaults body Return Call AttributeLoad NameLoad attr NameLoad keyword AttributeLoad NameLoad attr decorator_list decorator_list ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body If CompareIn AttributeLoad NameLoad attr AttributeLoad NameLoad attr body Return SubscriptLoad AttributeLoad NameLoad attr Index AttributeLoad NameLoad attr orelse Return AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str If CompareIn NameLoad AttributeLoad NameLoad attr body Raise Call AttributeLoad NameLoad attr BinOpMod Str NameLoad Assign NameStore Call AttributeLoad AttributeLoad NameLoad attr attr Assign SubscriptStore NameLoad Index NameLoad NameLoad Return Call NameLoad AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return AttributeLoad AttributeLoad NameLoad attr attr decorator_list NameLoad decorator_list FunctionDef arguments args NameParam defaults body Return AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam defaults vararg kwarg body If CompareIs NameLoad NameLoad body Return NameLoad If Call AttributeLoad NameLoad attr NameLoad body Return Call NameLoad NameLoad NameLoad orelse Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body If Call NameLoad NameLoad NameLoad body Assign NameStore Call NameLoad For NameStore SubscriptLoad AttributeLoad AttributeLoad NameLoad attr attr Slice Num Num body TryExcept body Assign NameStore SubscriptLoad NameLoad Index NameLoad Break handlers ExceptHandler type NameLoad body Pass orelse Return NameLoad If Call NameLoad AttributeLoad NameLoad attr NameLoad body Return NameLoad Return Call AttributeLoad NameLoad attr NameLoad decorator_list
N/A N/A Base types API.

 N/A exc util N/A operators visitors Visitable N/A BOOLEANTYPE None N/A INTEGERTYPE None N/A NULLTYPE None N/A STRINGTYPE None TypeEngine N/A Visitable N/A N/A 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`

     N/A _sqla_type True N/A _isnull False Comparator N/A N/A operators ColumnOperators N/A N/A Base class for custom comparison operations defined at the
        type level.  See :attr:`.TypeEngine.comparator_factory`.


         __init__ N/A N/A self expr N/A N/A N/A N/A self expr expr N/A __reduce__ N/A N/A self N/A N/A N/A N/A _reconstitute_comparator N/A N/A self expr N/A N/A N/A hashable True N/A Flag, if False, means values from this type aren't hashable.

    Used by the ORM when uniquing result lists.

     N/A comparator_factory Comparator N/A A :class:`.TypeEngine.Comparator` class which will apply
    to operations performed by owning :class:`.ColumnElement` objects.

    The :attr:`.comparator_factory` attribute is a hook consulted by
    the core expression system when column and SQL expression operations
    are performed.   When a :class:`.TypeEngine.Comparator` class is
    associated with this attribute, it allows custom re-definition of
    all existing operators, as well as definition of new operators.
    Existing operators include those provided by Python operator overloading
    such as :meth:`.operators.ColumnOperators.__add__` and
    :meth:`.operators.ColumnOperators.__eq__`,
    those provided as standard
    attributes of :class:`.operators.ColumnOperators` such as
    :meth:`.operators.ColumnOperators.like`
    and :meth:`.operators.ColumnOperators.in_`.

    Rudimentary usage of this hook is allowed through simple subclassing
    of existing types, or alternatively by using :class:`.TypeDecorator`.
    See the documentation section :ref:`types_operators` for examples.

    .. versionadded:: 0.8  The expression system was enhanced to support
      customization of operators on a per-type level.

     copy_value N/A N/A self value N/A N/A N/A value N/A literal_processor N/A N/A self dialect N/A N/A N/A Return 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.

        .. versionadded:: 0.9.0

         N/A None N/A bind_processor N/A N/A self dialect N/A N/A N/A 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``.

        :param dialect: Dialect instance in use.

         N/A None N/A result_processor N/A N/A self dialect coltype N/A N/A N/A 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``.

        :param dialect: Dialect instance in use.

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

         N/A None N/A column_expression N/A N/A self colexpr N/A N/A N/A 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.

        The method is evaluated at statement compile time, as opposed
        to statement construction time.

        See also:

        :ref:`types_sql_value_processing`

         N/A None N/A _has_column_expression N/A N/A self N/A N/A N/A 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.

         N/A N/A N/A N/A N/A self __class__ column_expression __code__ N/A N/A TypeEngine column_expression __code__ N/A N/A util memoized_property bind_expression N/A N/A self bindvalue N/A N/A N/A "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.

        The method is evaluated at statement compile time, as opposed
        to statement construction time.

        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.

        See also:

        :ref:`types_sql_value_processing`

         N/A None N/A _has_bind_expression N/A N/A self N/A N/A N/A 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.

         N/A N/A N/A N/A N/A self __class__ bind_expression __code__ N/A N/A TypeEngine bind_expression __code__ N/A N/A util memoized_property compare_values N/A N/A self x y N/A N/A N/A Compare two values for equality. N/A N/A x y N/A get_dbapi_type N/A N/A self dbapi N/A N/A N/A Return the corresponding type object from the underlying DB-API, if
        any.

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

         N/A None N/A python_type N/A N/A self N/A N/A N/A Return 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/A N/A NotImplementedError N/A property with_variant N/A N/A self type_ dialect_name N/A N/A N/A Produce 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:`~sqlalchemy.types.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.)

        .. versionadded:: 0.7.2

         N/A N/A Variant self N/A dialect_name N/A to_instance type_ N/A _type_affinity N/A N/A self N/A N/A N/A Return a rudimental 'affinity' value expressing the general class
        of type. N/A typ None N/A t N/A N/A self __class__ __mro__ N/A N/A N/A t N/A TypeEngine UserDefinedType N/A N/A typ N/A N/A N/A issubclass t N/A TypeEngine UserDefinedType N/A N/A typ t N/A N/A N/A self __class__ N/A N/A util memoized_property dialect_impl N/A N/A self dialect N/A N/A N/A Return a dialect-specific implementation for this
        :class:`.TypeEngine`.

         N/A N/A N/A N/A N/A N/A dialect _type_memos N/A self N/A impl N/A N/A N/A KeyError N/A N/A N/A N/A N/A self _dialect_info dialect N/A impl N/A _cached_literal_processor N/A N/A self dialect N/A N/A N/A Return a dialect-specific literal processor for this type. N/A N/A N/A N/A N/A N/A dialect _type_memos N/A self N/A literal N/A N/A N/A KeyError N/A N/A d N/A N/A self _dialect_info dialect N/A N/A d N/A literal lp N/A N/A N/A d N/A impl literal_processor dialect N/A lp N/A _cached_bind_processor N/A N/A self dialect N/A N/A N/A Return a dialect-specific bind processor for this type. N/A N/A N/A N/A N/A N/A dialect _type_memos N/A self N/A bind N/A N/A N/A KeyError N/A N/A d N/A N/A self _dialect_info dialect N/A N/A d N/A bind bp N/A N/A N/A d N/A impl bind_processor dialect N/A bp N/A _cached_result_processor N/A N/A self dialect coltype N/A N/A N/A Return a dialect-specific result processor for this type. N/A N/A N/A N/A N/A N/A dialect _type_memos N/A self N/A coltype N/A N/A N/A KeyError N/A N/A d N/A N/A self _dialect_info dialect N/A N/A d N/A coltype rp N/A N/A N/A d N/A impl result_processor dialect coltype N/A rp N/A _dialect_info N/A N/A self dialect N/A N/A N/A Return a dialect-specific registry which
        caches a dialect-specific implementation, bind processing
        function, and one or more result processing functions. N/A N/A self N/A dialect _type_memos N/A N/A N/A N/A dialect _type_memos N/A self N/A N/A impl N/A N/A self _gen_dialect_impl dialect N/A N/A impl self N/A N/A impl N/A N/A self adapt N/A type self N/A N/A impl self N/A N/A N/A dialect _type_memos N/A self d N/A impl impl N/A d N/A _gen_dialect_impl N/A N/A self dialect N/A N/A N/A N/A N/A dialect type_descriptor self N/A adapt N/A N/A self cls N/A kw N/A N/A 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.
         N/A N/A N/A util constructor_copy self cls kw N/A coerce_compared_value N/A N/A self op value N/A N/A N/A Suggest 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/A _coerced_type N/A N/A _type_map get N/A type value NULLTYPE N/A N/A N/A _coerced_type NULLTYPE N/A N/A _coerced_type _type_affinity N/A self _type_affinity N/A N/A self N/A N/A _coerced_type N/A _compare_type_affinity N/A N/A self other N/A N/A N/A N/A N/A self _type_affinity N/A other _type_affinity N/A compile N/A N/A self dialect N/A None N/A N/A 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.

         N/A N/A dialect N/A N/A dialect N/A N/A self _default_dialect N/A N/A N/A N/A dialect type_compiler process self N/A _default_dialect N/A N/A self default N/A N/A N/A N/A N/A N/A N/A self __class__ __module__ startswith sqlalchemy.dialects N/A N/A tokens N/A N/A N/A N/A N/A self __class__ __module__ split . N/A 0 3 N/A mod N/A N/A . join tokens N/A N/A N/A N/A getattr N/A N/A __import__ mod dialects N/A tokens N/A -1 dialect N/A N/A N/A N/A default DefaultDialect N/A N/A N/A util dependencies sqlalchemy.engine.default __str__ N/A N/A self N/A N/A N/A N/A util py2k N/A N/A N/A N/A N/A unicode N/A N/A self compile encode ascii backslashreplace N/A N/A N/A str N/A N/A self compile N/A __repr__ N/A N/A self N/A N/A N/A N/A N/A util generic_repr self N/A N/A UserDefinedType N/A TypeEngine N/A N/A 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):
          def __init__(self, precision = 8):
              self.precision = precision

          def get_col_spec(self):
              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', meta,
          Column('id', Integer, primary_key=True),
          Column('data', MyType(16))
          )

     N/A __visit_name__ user_defined Comparator N/A N/A TypeEngine Comparator N/A _adapt_expression N/A N/A self op other_comparator N/A N/A N/A N/A hasattr N/A self type adapt_operator N/A N/A N/A N/A util warn_deprecated UserDefinedType.adapt_operator is deprecated.  Create a UserDefinedType.Comparator subclass instead which generates the desired expression constructs, given a particular operator. N/A N/A N/A N/A N/A self type adapt_operator op N/A self type N/A N/A N/A op N/A self type N/A N/A N/A comparator_factory Comparator coerce_compared_value N/A N/A self op value N/A N/A N/A 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.

        .. versionchanged:: 0.8 :meth:`.UserDefinedType.coerce_compared_value`
           now returns ``self`` by default, rather than falling onto the
           more fundamental behavior of
           :meth:`.TypeEngine.coerce_compared_value`.

         N/A self N/A N/A TypeDecorator N/A TypeEngine N/A N/A 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

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

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

          def copy(self):
              return MyType(self.impl.length)

    The class-level "impl" attribute is required, and can reference any
    TypeEngine class.  Alternatively, the 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.

    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

     N/A __visit_name__ type_decorator __init__ N/A N/A self N/A args kwargs N/A N/A 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.

         N/A N/A N/A hasattr N/A self __class__ impl N/A N/A N/A AssertionError TypeDecorator implementations require a class-level variable 'impl' which refers to the class of type being decorated N/A N/A self impl N/A to_instance N/A N/A self __class__ impl args kwargs N/A N/A coerce_to_is_types N/A N/A util NoneType N/A Specify those Python types which should be coerced at the expression
    level to "IS <constant>" when compared using ``==`` (and same for
    ``IS NOT`` in conjunction with ``!=``.

    For most SQLAlchemy types, this includes ``NoneType``, as well as
    ``bool``.

    :class:`.TypeDecorator` modifies this list to only include ``NoneType``,
    as typedecorator implementations that deal with boolean types are common.

    Custom :class:`.TypeDecorator` classes can override this attribute to
    return an empty tuple, in which case no values will be coerced to
    constants.

    ..versionadded:: 0.8.2
        Added :attr:`.TypeDecorator.coerce_to_is_types` to allow for easier
        control of ``__eq__()`` ``__ne__()`` operations.

     Comparator N/A N/A TypeEngine Comparator N/A operate N/A N/A self op N/A other kwargs N/A N/A N/A kwargs N/A _python_is_types N/A N/A N/A self expr type coerce_to_is_types N/A N/A N/A N/A super N/A TypeDecorator Comparator self operate op other kwargs N/A reverse_operate N/A N/A self op other N/A kwargs N/A N/A N/A kwargs N/A _python_is_types N/A N/A N/A self expr type coerce_to_is_types N/A N/A N/A N/A super N/A TypeDecorator Comparator self reverse_operate op other kwargs N/A N/A comparator_factory N/A N/A self N/A N/A N/A N/A type TDComparator N/A N/A TypeDecorator Comparator N/A N/A self impl comparator_factory N/A N/A property _gen_dialect_impl N/A N/A self dialect N/A N/A N/A 
        #todo
         N/A adapted N/A N/A dialect type_descriptor self N/A N/A adapted self N/A N/A adapted N/A typedesc N/A N/A N/A N/A self load_dialect_impl dialect dialect_impl dialect N/A tt N/A N/A self copy N/A N/A N/A isinstance tt N/A self __class__ N/A N/A N/A AssertionError N/A Type object %s does not properly implement the copy() method, it must return an object of type %s N/A self N/A self __class__ N/A N/A tt impl typedesc N/A tt N/A _type_affinity N/A N/A self N/A N/A N/A 
        #todo
         N/A N/A N/A self impl _type_affinity N/A property type_engine N/A N/A self dialect N/A N/A N/A 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` but also traverses
        into wrapped :class:`.TypeDecorator` instances.
        Behavior can be customized here by overriding
        :meth:`load_dialect_impl`.

         N/A adapted N/A N/A dialect type_descriptor self N/A N/A N/A isinstance adapted N/A type self N/A N/A adapted N/A N/A N/A isinstance N/A self impl TypeDecorator N/A N/A N/A N/A N/A self impl type_engine dialect N/A N/A N/A N/A self load_dialect_impl dialect N/A load_dialect_impl N/A N/A self dialect N/A N/A N/A 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``.

         N/A N/A self impl N/A __getattr__ N/A N/A self key N/A N/A N/A Proxy all other undefined accessors to the underlying
        implementation. N/A N/A getattr N/A self impl key N/A process_literal_param N/A N/A self value dialect N/A N/A N/A Receive a literal parameter value to be rendered inline within
        a statement.

        This method is used when the compiler renders a
        literal value without using binds, typically within DDL
        such as in the "server default" of a column or an expression
        within a CHECK constraint.

        The returned string will be rendered into the output string.

        .. versionadded:: 0.9.0

         N/A N/A NotImplementedError N/A process_bind_param N/A N/A self value dialect N/A N/A N/A Receive a bound parameter value to be converted.

        Subclasses override this method to return the
        value that should be passed along to the underlying
        :class:`.TypeEngine` object, and from there to the
        DBAPI ``execute()`` method.

        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.

        This operation should be designed with the reverse operation
        in mind, which would be the process_result_value method of
        this class.

        :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.

         N/A N/A NotImplementedError N/A process_result_value N/A N/A self value dialect N/A N/A N/A Receive a result-row column value to be converted.

        Subclasses should implement this method to operate on data
        fetched from the database.

        Subclasses override this method to return the
        value that should be passed back to the application,
        given a value that is already processed by
        the underlying :class:`.TypeEngine` object, originally
        from the DBAPI cursor method ``fetchone()`` or similar.

        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.

        This operation should be designed to be reversible by
        the "process_bind_param" method of this class.

         N/A N/A NotImplementedError N/A _has_bind_processor N/A N/A self N/A N/A N/A 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.

         N/A N/A N/A N/A N/A self __class__ process_bind_param __code__ N/A N/A TypeDecorator process_bind_param __code__ N/A N/A util memoized_property _has_literal_processor N/A N/A self N/A N/A N/A memoized boolean, check if process_literal_param is implemented.


         N/A N/A N/A N/A N/A self __class__ process_literal_param __code__ N/A N/A TypeDecorator process_literal_param __code__ N/A N/A util memoized_property literal_processor N/A N/A self dialect N/A N/A N/A Provide a literal processing function for the given
        :class:`.Dialect`.

        Subclasses here will typically override
        :meth:`.TypeDecorator.process_literal_param` instead of this method
        directly.

        By default, this method makes use of
        :meth:`.TypeDecorator.process_bind_param` if that method is
        implemented, where :meth:`.TypeDecorator.process_literal_param` is
        not.  The rationale here is that :class:`.TypeDecorator` typically
        deals with Python conversions of data that are above the layer of
        database presentation.  With the value converted by
        :meth:`.TypeDecorator.process_bind_param`, the underlying type will
        then handle whether it needs to be presented to the DBAPI as a bound
        parameter or to the database as an inline SQL value.

        .. versionadded:: 0.9.0

         N/A N/A self _has_literal_processor N/A N/A process_param N/A self process_literal_param N/A N/A N/A self _has_bind_processor N/A N/A process_param N/A self process_bind_param N/A N/A process_param None N/A process_param N/A N/A impl_processor N/A N/A N/A self impl literal_processor dialect N/A impl_processor N/A process N/A N/A value N/A N/A N/A N/A impl_processor N/A process_param value dialect N/A N/A process N/A N/A value N/A N/A N/A N/A process_param value dialect N/A N/A process N/A N/A N/A N/A N/A self impl literal_processor dialect N/A bind_processor N/A N/A self dialect N/A N/A N/A 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.   :class:`.TypeDecorator`
        will wrap a user-defined implementation of
        :meth:`process_bind_param` here.

        User-defined code can override this method directly,
        though its likely best to use :meth:`process_bind_param` so that
        the processing provided by ``self.impl`` is maintained.

        :param dialect: Dialect instance in use.

        This method is the reverse counterpart to the
        :meth:`result_processor` method of this class.

         N/A N/A self _has_bind_processor N/A N/A process_param N/A self process_bind_param N/A impl_processor N/A N/A N/A self impl bind_processor dialect N/A impl_processor N/A process N/A N/A value N/A N/A N/A N/A impl_processor N/A process_param value dialect N/A N/A process N/A N/A value N/A N/A N/A N/A process_param value dialect N/A N/A process N/A N/A N/A N/A N/A self impl bind_processor dialect N/A _has_result_processor N/A N/A self N/A N/A N/A 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.

         N/A N/A N/A N/A N/A self __class__ process_result_value __code__ N/A N/A TypeDecorator process_result_value __code__ N/A N/A util memoized_property result_processor N/A N/A self dialect coltype N/A N/A N/A Provide a result value processing function for the given
        :class:`.Dialect`.

        This is the method that fulfills the :class:`.TypeEngine`
        contract for result value conversion.   :class:`.TypeDecorator`
        will wrap a user-defined implementation of
        :meth:`process_result_value` here.

        User-defined code can override this method directly,
        though its likely best to use :meth:`process_result_value` so that
        the processing provided by ``self.impl`` is maintained.

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

        This method is the reverse counterpart to the
        :meth:`bind_processor` method of this class.

         N/A N/A self _has_result_processor N/A N/A process_value N/A self process_result_value N/A impl_processor N/A N/A N/A self impl result_processor dialect coltype N/A impl_processor N/A process N/A N/A value N/A N/A N/A N/A process_value N/A impl_processor value dialect N/A N/A process N/A N/A value N/A N/A N/A N/A process_value value dialect N/A N/A process N/A N/A N/A N/A N/A self impl result_processor dialect coltype N/A coerce_compared_value N/A N/A self op value N/A N/A N/A 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.

         N/A self N/A copy N/A N/A self N/A N/A N/A 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.

         N/A instance N/A N/A N/A self __class__ __new__ N/A self __class__ N/A N/A N/A N/A instance __dict__ update N/A self __dict__ N/A instance N/A get_dbapi_type N/A N/A self dbapi N/A N/A N/A Return the DBAPI type object represented by this
        :class:`.TypeDecorator`.

        By default this calls upon :meth:`.TypeEngine.get_dbapi_type` of the
        underlying "impl".
         N/A N/A N/A N/A self impl get_dbapi_type dbapi N/A compare_values N/A N/A self x y N/A N/A N/A 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.

         N/A N/A N/A N/A self impl compare_values x y N/A __repr__ N/A N/A self N/A N/A N/A N/A N/A util generic_repr self to_inspect N/A self impl N/A N/A Variant N/A TypeDecorator N/A N/A 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.

    .. versionadded:: 0.7.2

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

     __init__ N/A N/A self base mapping N/A N/A N/A Construct a new :class:`.Variant`.

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

         N/A N/A self impl base N/A N/A self mapping mapping N/A load_dialect_impl N/A N/A self dialect N/A N/A N/A N/A N/A dialect name N/A self mapping N/A N/A N/A N/A self mapping N/A N/A dialect name N/A N/A N/A self impl N/A with_variant N/A N/A self type_ dialect_name N/A N/A N/A 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.)

         N/A N/A dialect_name N/A self mapping N/A N/A N/A N/A exc ArgumentError N/A Dialect '%s' is already present in the mapping for this Variant dialect_name N/A mapping N/A N/A N/A self mapping copy N/A N/A mapping N/A dialect_name type_ N/A N/A Variant N/A self impl mapping N/A comparator_factory N/A N/A self N/A N/A N/A express comparison behavior in terms of the base type N/A N/A N/A self impl comparator_factory N/A property N/A _reconstitute_comparator N/A N/A expression N/A N/A N/A N/A expression comparator N/A to_instance N/A N/A typeobj N/A arg kw N/A N/A N/A typeobj None N/A N/A NULLTYPE N/A N/A N/A util callable typeobj N/A N/A N/A typeobj arg kw N/A N/A typeobj N/A adapt_type N/A N/A typeobj colspecs N/A N/A N/A N/A isinstance typeobj type N/A N/A typeobj N/A typeobj N/A t N/A N/A N/A typeobj __class__ __mro__ N/A 0 -1 N/A N/A N/A N/A impltype N/A colspecs N/A t N/A N/A N/A N/A KeyError N/A N/A N/A N/A typeobj N/A N/A issubclass N/A typeobj __class__ impltype N/A N/A typeobj N/A N/A N/A typeobj adapt impltype N/A