class String(Concatenable, TypeEngine[
Known subclasses: sqlalchemy.dialects.postgresql.asyncpg.AsyncpgString
, sqlalchemy.sql.sqltypes.CHAR
, sqlalchemy.sql.sqltypes.Enum
, sqlalchemy.sql.sqltypes.Text
, sqlalchemy.sql.sqltypes.Unicode
, sqlalchemy.sql.sqltypes.VARCHAR
, sqlalchemy.dialects.mssql.pyodbc._String_pyodbc
, sqlalchemy.dialects.mysql.types._StringType
, sqlalchemy.dialects.oracle.cx_oracle._OracleString
, sqlalchemy.dialects.postgresql.pg8000._PGString
, sqlalchemy.dialects.postgresql.psycopg._PGString
The base for all string and character types. In SQL, corresponds to VARCHAR. The `length` field is usually required when the `String` type is used within a CREATE TABLE statement, as VARCHAR requires a length on most databases.
Method | __init__ |
Create a string-holding type. |
Method | bind |
Return a conversion function for processing bind values. |
Method | get |
Return the corresponding type object from the underlying DB-API, if any. |
Method | literal |
Return a conversion function for processing literal values that are to be rendered directly without using binds. |
Method | result |
Return a conversion function for processing result row values. |
Class Variable | __visit |
Undocumented |
Instance Variable | collation |
Undocumented |
Instance Variable | length |
Undocumented |
Property | python |
Return the Python type object expected to be returned by instances of this type, if known. |
Method | _resolve |
adjust this type given a literal Python value that will be stored in a bound parameter. |
Inherited from Concatenable
:
Class |
|
Undocumented |
Inherited from TypeEngineMixin
(via Concatenable
):
Method | adapt |
Undocumented |
Method | dialect |
Undocumented |
Class Variable | __slots__ |
Undocumented |
Property | _static |
Undocumented |
Inherited from TypeEngine
(via Concatenable
, TypeEngineMixin
):
Method | __repr__ |
Undocumented |
Method | __str__ |
Undocumented |
Method | as |
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. |
Method | bind |
Given a bind value (i.e. a :class:`.BindParameter` instance), return a SQL expression in its place. |
Method | coerce |
Suggest a type for a 'coerced' Python value in an expression. |
Method | column |
Given a SELECT column expression, return a wrapping SQL expression. |
Method | compare |
Compare this type against the given backend type. |
Method | compare |
Compare two values for equality. |
Method | compile |
Produce a string-compiled form of this :class:`.TypeEngine`. |
Method | copy |
Undocumented |
Method | copy |
Undocumented |
Method | evaluates |
Return a copy of this type which has the :attr:`.should_evaluate_none` flag set to True. |
Method | with |
Produce a copy of this type object that will utilize the given type when applied to the dialect of the given name. |
Class Variable | hashable |
Flag, if False, means values from this type aren't hashable. |
Class Variable | render |
Render bind casts for :attr:`.BindTyping.RENDER_CASTS` mode. |
Class Variable | render |
render casts when rendering a value as an inline literal, e.g. with :meth:`.TypeEngine.literal_processor`. |
Class Variable | should |
If True, the Python constant ``None`` is considered to be handled explicitly by this type. |
Class Variable | sort |
A sorting function that can be passed as the key to sorted. |
Static Method | _to |
Undocumented |
Method | _cached |
Return a dialect-specific bind processor for this type. |
Method | _cached |
return a dialect-specific processing object for custom purposes. |
Method | _cached |
Return a dialect-specific literal processor for this type. |
Method | _cached |
Return a dialect-specific result processor for this type. |
Method | _compare |
Undocumented |
Method | _default |
Undocumented |
Method | _dialect |
Return a dialect-specific registry which caches a dialect-specific implementation, bind processing function, and one or more result processing functions. |
Method | _gen |
Undocumented |
Method | _resolve |
given a Python type (e.g. ``int``, ``str``, etc. ) return an instance of this :class:`.TypeEngine` that's appropriate for this type. |
Method | _unwrapped |
Return the 'unwrapped' dialect impl for this type. |
Class Variable | _is |
Undocumented |
Class Variable | _is |
Undocumented |
Class Variable | _is |
Undocumented |
Class Variable | _is |
Undocumented |
Class Variable | _isnull |
Undocumented |
Class Variable | _sqla |
Undocumented |
Property | _generic |
Undocumented |
Property | _has |
memoized boolean, check if bind_expression is implemented. |
Property | _has |
memoized boolean, check if column_expression is implemented. |
Property | _type |
Return a rudimental 'affinity' value expressing the general class of type. |
Inherited from Visitable
(via Concatenable
, TypeEngineMixin
, TypeEngine
):
Method | __class |
Undocumented |
Method | __init |
Undocumented |
Class Method | _generate |
Undocumented |
Method | _compiler |
Undocumented |
Class Variable | _original |
Undocumented |
sqlalchemy.dialects.mysql.CHAR
, sqlalchemy.dialects.mysql.TEXT
, sqlalchemy.dialects.mysql.VARCHAR
, sqlalchemy.sql.sqltypes.Enum
, sqlalchemy.sql.sqltypes.Unicode
, sqlalchemy.sql.sqltypes.UnicodeText
, sqlalchemy.dialects.mysql.types._StringType
Create a string-holding type. :param length: optional, a length for the column for use in DDL and CAST expressions. May be safely omitted if no ``CREATE TABLE`` will be issued. Certain databases may require a ``length`` for use in DDL, and will raise an exception when the ``CREATE TABLE`` DDL is issued if a ``VARCHAR`` with no length is included. Whether the value is interpreted as bytes or characters is database specific. :param collation: Optional, a column-level collation for use in DDL and CAST expressions. Renders using the COLLATE keyword supported by SQLite, MySQL, and PostgreSQL. E.g.: .. sourcecode:: pycon+sql >>> from sqlalchemy import cast, select, String >>> print(select(cast('some string', String(collation='utf8')))) {printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1 .. note:: In most cases, the :class:`.Unicode` or :class:`.UnicodeText` datatypes should be used for a :class:`_schema.Column` that expects to store non-ascii data. These datatypes will ensure that the correct types are used on the database.
sqlalchemy.dialects.mysql.SET
, sqlalchemy.sql.sqltypes.Enum
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.
sqlalchemy.dialects.postgresql.ENUM
, sqlalchemy.dialects.mssql.pyodbc._String_pyodbc
, sqlalchemy.dialects.mssql.pyodbc._Unicode_pyodbc
, sqlalchemy.dialects.mssql.pyodbc._UnicodeText_pyodbc
, sqlalchemy.dialects.oracle.cx_oracle._OracleChar
, sqlalchemy.dialects.oracle.cx_oracle._OracleLong
, sqlalchemy.dialects.oracle.cx_oracle._OracleNChar
, sqlalchemy.dialects.oracle.cx_oracle._OracleText
, sqlalchemy.dialects.oracle.cx_oracle._OracleUnicodeStringCHAR
, sqlalchemy.dialects.oracle.cx_oracle._OracleUnicodeTextCLOB
, sqlalchemy.dialects.oracle.cx_oracle._OracleUnicodeTextNCLOB
Return the corresponding type object from the underlying DB-API, if any. This can be useful for calling ``setinputsizes()``, for example.
sqlalchemy.sql.sqltypes.Enum
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. 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`
sqlalchemy.dialects.mysql.SET
, sqlalchemy.sql.sqltypes.Enum
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.
sqlalchemy.dialects.mysql.CHAR
, sqlalchemy.dialects.mysql.ENUM
, sqlalchemy.dialects.mysql.LONGTEXT
, sqlalchemy.dialects.mysql.MEDIUMTEXT
, sqlalchemy.dialects.mysql.NCHAR
, sqlalchemy.dialects.mysql.NVARCHAR
, sqlalchemy.dialects.mysql.SET
, sqlalchemy.dialects.mysql.TEXT
, sqlalchemy.dialects.mysql.TINYTEXT
, sqlalchemy.dialects.mysql.VARCHAR
, sqlalchemy.sql.sqltypes.CHAR
, sqlalchemy.sql.sqltypes.Enum
, sqlalchemy.sql.sqltypes.Text
, sqlalchemy.sql.sqltypes.Unicode
, sqlalchemy.sql.sqltypes.VARCHAR
Undocumented
sqlalchemy.sql.sqltypes.Enum
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.
sqlalchemy.sql.sqltypes.Enum
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 TODO: this should be part of public API .. seealso:: :meth:`.TypeEngine._resolve_for_python_type`