Participer au site avec un Tip
Rechercher
 

Bug Suggérer des Améliorations / Corrections

Links Mon profile Linkedin Notre chaîne YouTube Notre discord

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Vous êtes un professionnel et vous avez besoin d'une formation ? Deep Learning avec Python
et Keras et Tensorflow Voir le programme détaillé

Contenu du module « sqlalchemy »

Liste des classes du module sqlalchemy

Nom de la classe Description
AdaptedConnection Interface of an adapted connection object to support the DBAPI protocol. [extrait de AdaptedConnection.__doc__]
Alias Represents an table or selectable alias (AS). [extrait de Alias.__doc__]
AliasedReturnsRows Base class of aliases against tables, subqueries, and other [extrait de AliasedReturnsRows.__doc__]
Any Special type indicating an unconstrained type. [extrait de Any.__doc__]
ARRAY Represent a SQL Array type. [extrait de ARRAY.__doc__]
AssertionPool A :class:`_pool.Pool` that allows at most one checked out connection at [extrait de AssertionPool.__doc__]
AsyncAdaptedQueuePool An asyncio-compatible version of :class:`.QueuePool`. [extrait de AsyncAdaptedQueuePool.__doc__]
BaseDDLElement The root of DDL constructs, including those that are sub-elements [extrait de BaseDDLElement.__doc__]
BaseRow
BIGINT The SQL BIGINT type. [extrait de BIGINT.__doc__]
BigInteger A type for bigger ``int`` integers. [extrait de BigInteger.__doc__]
BINARY The SQL BINARY type. [extrait de BINARY.__doc__]
BinaryExpression Represent an expression that is ``LEFT <operator> RIGHT``. [extrait de BinaryExpression.__doc__]
BindParameter Represent a "bound expression". [extrait de BindParameter.__doc__]
BindTyping Define different methods of passing typing information for [extrait de BindTyping.__doc__]
BLOB The SQL BLOB type. [extrait de BLOB.__doc__]
BOOLEAN The SQL BOOLEAN type. [extrait de BOOLEAN.__doc__]
Boolean A bool datatype. [extrait de Boolean.__doc__]
BooleanClauseList
CacheKey The key used to identify a SQL statement construct in the [extrait de CacheKey.__doc__]
Case Represent a ``CASE`` expression. [extrait de Case.__doc__]
Cast Represent a ``CAST`` expression. [extrait de Cast.__doc__]
CHAR The SQL CHAR type. [extrait de CHAR.__doc__]
CheckConstraint A table- or column-level CHECK constraint. [extrait de CheckConstraint.__doc__]
ChunkedIteratorResult An :class:`_engine.IteratorResult` that works from an [extrait de ChunkedIteratorResult.__doc__]
ClauseElement Base class for elements of a programmatically constructed SQL [extrait de ClauseElement.__doc__]
ClauseList Describe a list of clauses, separated by an operator. [extrait de ClauseList.__doc__]
CLOB The CLOB type. [extrait de CLOB.__doc__]
CollectionAggregate Forms the basis for right-hand collection operator modifiers [extrait de CollectionAggregate.__doc__]
Column Represents a column in a database table. [extrait de Column.__doc__]
ColumnClause Represents a column expression from any textual string. [extrait de ColumnClause.__doc__]
ColumnCollection Collection of :class:`_expression.ColumnElement` instances, [extrait de ColumnCollection.__doc__]
ColumnDefault A plain default value on a column. [extrait de ColumnDefault.__doc__]
ColumnElement Represent a column-oriented SQL expression suitable for usage in the [extrait de ColumnElement.__doc__]
ColumnOperators Defines boolean, comparison, and other operators for [extrait de ColumnOperators.__doc__]
Compiled Represent a compiled SQL or DDL expression. [extrait de Compiled.__doc__]
CompoundSelect Forms the basis of ``UNION``, ``UNION ALL``, and other [extrait de CompoundSelect.__doc__]
Computed Defines a generated column, i.e. "GENERATED ALWAYS AS" syntax. [extrait de Computed.__doc__]
Connection Provides high-level functionality for a wrapped DB-API connection. [extrait de Connection.__doc__]
Constraint A table-level SQL constraint. [extrait de Constraint.__doc__]
CreateEnginePlugin A set of hooks intended to augment the construction of an [extrait de CreateEnginePlugin.__doc__]
CTE Represent a Common Table Expression. [extrait de CTE.__doc__]
CursorResult A Result that is representing state from a DBAPI cursor. [extrait de CursorResult.__doc__]
custom_op Represent a 'custom' operator. [extrait de custom_op.__doc__]
DATE The SQL DATE type. [extrait de DATE.__doc__]
Date A type for ``datetime.date()`` objects. [extrait de Date.__doc__]
DATETIME The SQL DATETIME type. [extrait de DATETIME.__doc__]
DateTime A type for ``datetime.datetime()`` objects. [extrait de DateTime.__doc__]
DDL A literal DDL statement. [extrait de DDL.__doc__]
DECIMAL The SQL DECIMAL type. [extrait de DECIMAL.__doc__]
DefaultClause A DDL-specified DEFAULT column value. [extrait de DefaultClause.__doc__]
Delete Represent a DELETE construct. [extrait de Delete.__doc__]
Dialect Define the behavior of a specific database and DB-API combination. [extrait de Dialect.__doc__]
DOUBLE The SQL DOUBLE type. [extrait de DOUBLE.__doc__]
Double A type for double ``FLOAT`` floating point types. [extrait de Double.__doc__]
DOUBLE_PRECISION The SQL DOUBLE PRECISION type. [extrait de DOUBLE_PRECISION.__doc__]
Engine
Enum Generic Enum Type. [extrait de Enum.__doc__]
ExceptionContext Encapsulate information about an error condition in progress. [extrait de ExceptionContext.__doc__]
Executable Mark a :class:`_expression.ClauseElement` as supporting execution. [extrait de Executable.__doc__]
ExecutableDDLElement Base class for standalone executable DDL expression constructs. [extrait de ExecutableDDLElement.__doc__]
ExecutionContext A messenger object for a Dialect that corresponds to a single [extrait de ExecutionContext.__doc__]
Exists Represent an ``EXISTS`` clause. [extrait de Exists.__doc__]
Extract Represent a SQL EXTRACT clause, ``extract(field FROM expr)``. [extrait de Extract.__doc__]
FallbackAsyncAdaptedQueuePool
False_ Represent the ``false`` keyword, or equivalent, in a SQL statement. [extrait de False_.__doc__]
FetchedValue A marker for a transparent database-side default. [extrait de FetchedValue.__doc__]
FLOAT The SQL FLOAT type. [extrait de FLOAT.__doc__]
Float Type representing floating point types, such as ``FLOAT`` or ``REAL``. [extrait de Float.__doc__]
ForeignKey Defines a dependency between two columns. [extrait de ForeignKey.__doc__]
ForeignKeyConstraint A table-level FOREIGN KEY constraint. [extrait de ForeignKeyConstraint.__doc__]
FromClause Represent an element that can be used within the ``FROM`` [extrait de FromClause.__doc__]
FromGrouping Represent a grouping of a FROM clause [extrait de FromGrouping.__doc__]
FrozenResult Represents a :class:`_engine.Result` object in a "frozen" state suitable [extrait de FrozenResult.__doc__]
Function Describe a named SQL function. [extrait de Function.__doc__]
FunctionElement Base for SQL function-oriented constructs. [extrait de FunctionElement.__doc__]
FunctionFilter Represent a function FILTER clause. [extrait de FunctionFilter.__doc__]
GenerativeSelect Base class for SELECT statements where additional elements can be [extrait de GenerativeSelect.__doc__]
Grouping Represent a grouping within a column expression [extrait de Grouping.__doc__]
HasCTE Mixin that declares a class to include CTE support. [extrait de HasCTE.__doc__]
HasPrefixes
HasSuffixes
Identity Defines an identity column, i.e. "GENERATED { ALWAYS | BY DEFAULT } [extrait de Identity.__doc__]
Index A table-level INDEX. [extrait de Index.__doc__]
Insert Represent an INSERT construct. [extrait de Insert.__doc__]
Inspector Performs database schema inspection. [extrait de Inspector.__doc__]
INTEGER The SQL INT or INTEGER type. [extrait de INTEGER.__doc__]
Integer A type for ``int`` integers. [extrait de Integer.__doc__]
Interval A type for ``datetime.timedelta()`` objects. [extrait de Interval.__doc__]
IteratorResult A :class:`_engine.Result` that gets data from a Python iterator of [extrait de IteratorResult.__doc__]
Join Represent a ``JOIN`` construct between two [extrait de Join.__doc__]
JSON Represent a SQL JSON type. [extrait de JSON.__doc__]
Label Represents a column label (AS). [extrait de Label.__doc__]
LambdaElement A SQL construct where the state is stored as an un-invoked lambda. [extrait de LambdaElement.__doc__]
LargeBinary A type for large binary byte data. [extrait de LargeBinary.__doc__]
Lateral Represent a LATERAL subquery. [extrait de Lateral.__doc__]
MappingResult A wrapper for a :class:`_engine.Result` that returns dictionary values [extrait de MappingResult.__doc__]
MergedResult A :class:`_engine.Result` that is merged from any number of [extrait de MergedResult.__doc__]
MetaData A collection of :class:`_schema.Table` [extrait de MetaData.__doc__]
NCHAR The SQL NCHAR type. [extrait de NCHAR.__doc__]
NestedTransaction Represent a 'nested', or SAVEPOINT transaction. [extrait de NestedTransaction.__doc__]
Null Represent the NULL keyword in a SQL statement. [extrait de Null.__doc__]
NullPool A Pool which does not pool connections. [extrait de NullPool.__doc__]
NUMERIC The SQL NUMERIC type. [extrait de NUMERIC.__doc__]
Numeric Base for non-integer numeric types, such as [extrait de Numeric.__doc__]
NVARCHAR The SQL NVARCHAR type. [extrait de NVARCHAR.__doc__]
Operators Base of comparison and logical operators. [extrait de Operators.__doc__]
Over Represent an OVER clause. [extrait de Over.__doc__]
PickleType Holds Python objects, which are serialized using pickle. [extrait de PickleType.__doc__]
Pool Abstract base class for connection pools. [extrait de Pool.__doc__]
PoolProxiedConnection A connection-like adapter for a :pep:`249` DBAPI connection, which [extrait de PoolProxiedConnection.__doc__]
PoolResetState describes the state of a DBAPI connection as it is being passed to [extrait de PoolResetState.__doc__]
PrimaryKeyConstraint A table-level PRIMARY KEY constraint. [extrait de PrimaryKeyConstraint.__doc__]
QueuePool A :class:`_pool.Pool` [extrait de QueuePool.__doc__]
quoted_name Represent a SQL identifier combined with quoting preferences. [extrait de quoted_name.__doc__]
REAL The SQL REAL type. [extrait de REAL.__doc__]
ReleaseSavepointClause
Result Represent a set of database results. [extrait de Result.__doc__]
ReturnsRows The base-most class for Core constructs that have some concept of [extrait de ReturnsRows.__doc__]
RollbackToSavepointClause
RootTransaction Represent the "root" transaction on a :class:`_engine.Connection`. [extrait de RootTransaction.__doc__]
Row Represent a single result row. [extrait de Row.__doc__]
RowMapping A ``Mapping`` that maps column names and objects to :class:`.Row` [extrait de RowMapping.__doc__]
SavepointClause
ScalarResult A wrapper for a :class:`_engine.Result` that returns scalar values [extrait de ScalarResult.__doc__]
ScalarSelect Represent a scalar subquery. [extrait de ScalarSelect.__doc__]
Select Represents a ``SELECT`` statement. [extrait de Select.__doc__]
Selectable Mark a class as being selectable. [extrait de Selectable.__doc__]
SelectBase Base class for SELECT statements. [extrait de SelectBase.__doc__]
SelectLabelStyle Label style constants that may be passed to [extrait de SelectLabelStyle.__doc__]
Sequence Represents a named database sequence. [extrait de Sequence.__doc__]
SingletonThreadPool A Pool that maintains one connection per thread. [extrait de SingletonThreadPool.__doc__]
SMALLINT The SQL SMALLINT type. [extrait de SMALLINT.__doc__]
SmallInteger A type for smaller ``int`` integers. [extrait de SmallInteger.__doc__]
SQLColumnExpression A type that may be used to indicate any SQL column element or object [extrait de SQLColumnExpression.__doc__]
StatementLambdaElement Represent a composable SQL statement as a :class:`_sql.LambdaElement`. [extrait de StatementLambdaElement.__doc__]
StaticPool A Pool of exactly one connection, used for all requests. [extrait de StaticPool.__doc__]
String The base for all string and character types. [extrait de String.__doc__]
Subquery Represent a subquery of a SELECT. [extrait de Subquery.__doc__]
Table Represent a table in a database. [extrait de Table.__doc__]
TableClause Represents a minimal "table" construct. [extrait de TableClause.__doc__]
TableSample Represent a TABLESAMPLE clause. [extrait de TableSample.__doc__]
TableValuedAlias An alias against a "table valued" SQL function. [extrait de TableValuedAlias.__doc__]
TEXT The SQL TEXT type. [extrait de TEXT.__doc__]
Text A variably sized string type. [extrait de Text.__doc__]
TextClause Represent a literal SQL text fragment. [extrait de TextClause.__doc__]
TextualSelect Wrap a :class:`_expression.TextClause` construct within a [extrait de TextualSelect.__doc__]
TIME The SQL TIME type. [extrait de TIME.__doc__]
Time A type for ``datetime.time()`` objects. [extrait de Time.__doc__]
TIMESTAMP The SQL TIMESTAMP type. [extrait de TIMESTAMP.__doc__]
Transaction Represent a database transaction in progress. [extrait de Transaction.__doc__]
True_ Represent the ``true`` keyword, or equivalent, in a SQL statement. [extrait de True_.__doc__]
TryCast Represent a TRY_CAST expression. [extrait de TryCast.__doc__]
Tuple Represent a SQL tuple. [extrait de Tuple.__doc__]
TupleType represent the composite type of a Tuple. [extrait de TupleType.__doc__]
TwoPhaseTransaction Represent a two-phase transaction. [extrait de TwoPhaseTransaction.__doc__]
TypeClause Handle a type keyword in a SQL statement. [extrait de TypeClause.__doc__]
TypeCoerce Represent a Python-side type-coercion wrapper. [extrait de TypeCoerce.__doc__]
TypeCompiler Produces DDL specification for TypeEngine objects. [extrait de TypeCompiler.__doc__]
TypeDecorator Allows the creation of types which add additional functionality [extrait de TypeDecorator.__doc__]
UnaryExpression Define a 'unary' expression. [extrait de UnaryExpression.__doc__]
Unicode A variable length Unicode string type. [extrait de Unicode.__doc__]
UnicodeText An unbounded-length Unicode string type. [extrait de UnicodeText.__doc__]
UniqueConstraint A table-level UNIQUE constraint. [extrait de UniqueConstraint.__doc__]
Update Represent an Update construct. [extrait de Update.__doc__]
UpdateBase Form the base for ``INSERT``, ``UPDATE``, and ``DELETE`` statements. [extrait de UpdateBase.__doc__]
URL
UUID Represent the SQL UUID type. [extrait de UUID.__doc__]
Uuid Represent a database agnostic UUID datatype. [extrait de Uuid.__doc__]
Values Represent a ``VALUES`` construct that can be used as a FROM element [extrait de Values.__doc__]
ValuesBase Supplies support for :meth:`.ValuesBase.values` to [extrait de ValuesBase.__doc__]
VARBINARY The SQL VARBINARY type. [extrait de VARBINARY.__doc__]
VARCHAR The SQL VARCHAR type. [extrait de VARCHAR.__doc__]
Visitable Base class for visitable objects. [extrait de Visitable.__doc__]
WithinGroup Represent a WITHIN GROUP (ORDER BY) clause. [extrait de WithinGroup.__doc__]

Liste des fonctions du module sqlalchemy

Signature de la fonction Description
alias(selectable: 'FromClause', name: 'Optional[str]' = None, flat: 'bool' = False) -> 'NamedFromClause' Return a named alias of the given :class:`.FromClause`. [extrait de alias.__doc__]
all_(expr: '_ColumnExpressionArgument[_T]') -> 'CollectionAggregate[bool]' Produce an ALL expression. [extrait de all_.__doc__]
and_(*clauses) Produce a conjunction of expressions joined by ``AND``. [extrait de and_.__doc__]
any_(expr: '_ColumnExpressionArgument[_T]') -> 'CollectionAggregate[bool]' Produce an ANY expression. [extrait de any_.__doc__]
asc(column: '_ColumnExpressionOrStrLabelArgument[_T]') -> 'UnaryExpression[_T]' Produce an ascending ``ORDER BY`` clause element. [extrait de asc.__doc__]
between(expr: '_ColumnExpressionOrLiteralArgument[_T]', lower_bound: 'Any', upper_bound: 'Any', symmetric: 'bool' = False) -> 'BinaryExpression[bool]' Produce a ``BETWEEN`` predicate clause. [extrait de between.__doc__]
bindparam(key: 'Optional[str]', value: 'Any' = _NoArg.NO_ARG, type_: 'Optional[_TypeEngineArgument[_T]]' = None, unique: 'bool' = False, required: 'Union[bool, Literal[_NoArg.NO_ARG]]' = _NoArg.NO_ARG, quote: 'Optional[bool]' = None, callable_: 'Optional[Callable[[], Any]]' = None, expanding: 'bool' = False, isoutparam: 'bool' = False, literal_execute: 'bool' = False) -> 'BindParameter[_T]' Produce a "bound expression". [extrait de bindparam.__doc__]
bitwise_not(expr: '_ColumnExpressionArgument[_T]') -> 'UnaryExpression[_T]' Produce a unary bitwise NOT clause, typically via the ``~`` operator. [extrait de bitwise_not.__doc__]
case(*whens: 'Union[typing_Tuple[_ColumnExpressionArgument[bool], Any], Mapping[Any, Any]]', value: 'Optional[Any]' = None, else_: 'Optional[Any]' = None) -> 'Case[Any]' Produce a ``CASE`` expression. [extrait de case.__doc__]
cast(expression: '_ColumnExpressionOrLiteralArgument[Any]', type_: '_TypeEngineArgument[_T]') -> 'Cast[_T]' Produce a ``CAST`` expression. [extrait de cast.__doc__]
collate(expression: '_ColumnExpressionArgument[str]', collation: 'str') -> 'BinaryExpression[str]' Return the clause ``expression COLLATE collation``. [extrait de collate.__doc__]
column(text: 'str', type_: 'Optional[_TypeEngineArgument[_T]]' = None, is_literal: 'bool' = False, _selectable: 'Optional[FromClause]' = None) -> 'ColumnClause[_T]' Produce a :class:`.ColumnClause` object. [extrait de column.__doc__]
create_engine(url: 'Union[str, _url.URL]', **kwargs: 'Any') -> 'Engine' Create a new :class:`_engine.Engine` instance. [extrait de create_engine.__doc__]
create_mock_engine(url: 'Union[str, URL]', executor: 'Any', **kw: 'Any') -> 'MockConnection' Create a "mock" engine used for echoing DDL. [extrait de create_mock_engine.__doc__]
create_pool_from_url(url: 'Union[str, URL]', **kwargs: 'Any') -> 'Pool' Create a pool instance from the given url. [extrait de create_pool_from_url.__doc__]
cte(selectable: 'HasCTE', name: 'Optional[str]' = None, recursive: 'bool' = False) -> 'CTE' Return a new :class:`_expression.CTE`, [extrait de cte.__doc__]
delete(table: '_DMLTableArgument') -> 'Delete' Construct :class:`_expression.Delete` object. [extrait de delete.__doc__]
desc(column: '_ColumnExpressionOrStrLabelArgument[_T]') -> 'UnaryExpression[_T]' Produce a descending ``ORDER BY`` clause element. [extrait de desc.__doc__]
distinct(expr: '_ColumnExpressionArgument[_T]') -> 'UnaryExpression[_T]' Produce an column-expression-level unary ``DISTINCT`` clause. [extrait de distinct.__doc__]
engine_from_config(configuration: 'Dict[str, Any]', prefix: 'str' = 'sqlalchemy.', **kwargs: 'Any') -> 'Engine' Create a new Engine instance using a configuration dictionary. [extrait de engine_from_config.__doc__]
except_(*selects: '_SelectStatementForCompoundArgument') -> 'CompoundSelect' Return an ``EXCEPT`` of multiple selectables. [extrait de except_.__doc__]
except_all(*selects: '_SelectStatementForCompoundArgument') -> 'CompoundSelect' Return an ``EXCEPT ALL`` of multiple selectables. [extrait de except_all.__doc__]
exists(__argument: 'Optional[Union[_ColumnsClauseArgument[Any], SelectBase, ScalarSelect[Any]]]' = None) -> 'Exists' Construct a new :class:`_expression.Exists` construct. [extrait de exists.__doc__]
extract(field: 'str', expr: '_ColumnExpressionArgument[Any]') -> 'Extract' Return a :class:`.Extract` construct. [extrait de extract.__doc__]
false() -> 'False_' Return a :class:`.False_` construct. [extrait de false.__doc__]
func(*c: 'Any', **kwargs: 'Any') -> 'Function[Any]' Generate SQL function expressions. [extrait de __doc__]
funcfilter(func: 'FunctionElement[_T]', *criterion: '_ColumnExpressionArgument[bool]') -> 'FunctionFilter[_T]' Produce a :class:`.FunctionFilter` object against a function. [extrait de funcfilter.__doc__]
insert(table: '_DMLTableArgument') -> 'Insert' Construct an :class:`_expression.Insert` object. [extrait de insert.__doc__]
insert_sentinel(name: 'Optional[str]' = None, type_: 'Optional[_TypeEngineArgument[_T]]' = None, *, default: 'Optional[Any]' = None, omit_from_statements: 'bool' = True) -> 'Column[Any]' Provides a surrogate :class:`_schema.Column` that will act as a [extrait de insert_sentinel.__doc__]
inspect(subject: 'Any', raiseerr: 'bool' = True) -> 'Any' Produce an inspection object for the given target. [extrait de inspect.__doc__]
intersect(*selects: '_SelectStatementForCompoundArgument') -> 'CompoundSelect' Return an ``INTERSECT`` of multiple selectables. [extrait de intersect.__doc__]
intersect_all(*selects: '_SelectStatementForCompoundArgument') -> 'CompoundSelect' Return an ``INTERSECT ALL`` of multiple selectables. [extrait de intersect_all.__doc__]
join(left: '_FromClauseArgument', right: '_FromClauseArgument', onclause: 'Optional[_OnClauseArgument]' = None, isouter: 'bool' = False, full: 'bool' = False) -> 'Join' Produce a :class:`_expression.Join` object, given two [extrait de join.__doc__]
label(name: 'str', element: '_ColumnExpressionArgument[_T]', type_: 'Optional[_TypeEngineArgument[_T]]' = None) -> 'Label[_T]' Return a :class:`Label` object for the [extrait de label.__doc__]
lambda_stmt(lmb: '_StmtLambdaType', enable_tracking: 'bool' = True, track_closure_variables: 'bool' = True, track_on: 'Optional[object]' = None, global_track_bound_values: 'bool' = True, track_bound_values: 'bool' = True, lambda_cache: 'Optional[_LambdaCacheType]' = None) -> 'StatementLambdaElement' Produce a SQL statement that is cached as a lambda. [extrait de lambda_stmt.__doc__]
lateral(selectable: 'Union[SelectBase, _FromClauseArgument]', name: 'Optional[str]' = None) -> 'LateralFromClause' Return a :class:`_expression.Lateral` object. [extrait de lateral.__doc__]
literal(value: 'Any', type_: 'Optional[_TypeEngineArgument[Any]]' = None, literal_execute: 'bool' = False) -> 'BindParameter[Any]' Return a literal clause, bound to a bind parameter. [extrait de literal.__doc__]
literal_column(text: 'str', type_: 'Optional[_TypeEngineArgument[_T]]' = None) -> 'ColumnClause[_T]' Produce a :class:`.ColumnClause` object that has the [extrait de literal_column.__doc__]
make_url(name_or_url: 'Union[str, URL]') -> 'URL' Given a string, produce a new URL instance. [extrait de make_url.__doc__]
modifier(*c: 'Any', **kwargs: 'Any') -> 'Function[Any]' Generate SQL function expressions. [extrait de __doc__]
not_(clause: '_ColumnExpressionArgument[_T]') -> 'ColumnElement[_T]' Return a negation of the given clause, i.e. ``NOT(clause)``. [extrait de not_.__doc__]
NotNullable(val: 'Union[_TypedColumnClauseArgument[Optional[_T]], Optional[Type[_T]]]') -> '_TypedColumnClauseArgument[_T]' Types a column or ORM class as not nullable. [extrait de NotNullable.__doc__]
null() -> 'Null' Return a constant :class:`.Null` construct. [extrait de null.__doc__]
Nullable(val: '_TypedColumnClauseArgument[_T]') -> '_TypedColumnClauseArgument[Optional[_T]]' Types a column or ORM class as nullable. [extrait de Nullable.__doc__]
nulls_first(column: '_ColumnExpressionArgument[_T]') -> 'UnaryExpression[_T]' Produce the ``NULLS FIRST`` modifier for an ``ORDER BY`` expression. [extrait de nulls_first.__doc__]
nulls_last(column: '_ColumnExpressionArgument[_T]') -> 'UnaryExpression[_T]' Produce the ``NULLS LAST`` modifier for an ``ORDER BY`` expression. [extrait de nulls_last.__doc__]
or_(*clauses) Produce a conjunction of expressions joined by ``OR``. [extrait de or_.__doc__]
outerjoin(left: '_FromClauseArgument', right: '_FromClauseArgument', onclause: 'Optional[_OnClauseArgument]' = None, full: 'bool' = False) -> 'Join' Return an ``OUTER JOIN`` clause element. [extrait de outerjoin.__doc__]
outparam(key: 'str', type_: 'Optional[TypeEngine[_T]]' = None) -> 'BindParameter[_T]' Create an 'OUT' parameter for usage in functions (stored procedures), [extrait de outparam.__doc__]
over(element: 'FunctionElement[_T]', partition_by: 'Optional[_ByArgument]' = None, order_by: 'Optional[_ByArgument]' = None, range_: 'Optional[typing_Tuple[Optional[int], Optional[int]]]' = None, rows: 'Optional[typing_Tuple[Optional[int], Optional[int]]]' = None) -> 'Over[_T]' Produce an :class:`.Over` object against a function. [extrait de over.__doc__]
result_tuple(fields: 'Sequence[str]', extra: 'Optional[Any]' = None) -> 'Callable[[Iterable[Any]], Row[Any]]'
select(*entities: '_ColumnsClauseArgument[Any]', **__kw: 'Any') -> 'Select[Any]' Construct a new :class:`_expression.Select`. [extrait de select.__doc__]
table(name: 'str', *columns: 'ColumnClause[Any]', **kw: 'Any') -> 'TableClause' Produce a new :class:`_expression.TableClause`. [extrait de table.__doc__]
tablesample(selectable: '_FromClauseArgument', sampling: 'Union[float, Function[Any]]', name: 'Optional[str]' = None, seed: 'Optional[roles.ExpressionElementRole[Any]]' = None) -> 'TableSample' Return a :class:`_expression.TableSample` object. [extrait de tablesample.__doc__]
text(text: 'str') -> 'TextClause' Construct a new :class:`_expression.TextClause` clause, [extrait de text.__doc__]
true() -> 'True_' Return a constant :class:`.True_` construct. [extrait de true.__doc__]
try_cast(expression: '_ColumnExpressionOrLiteralArgument[Any]', type_: '_TypeEngineArgument[_T]') -> 'TryCast[_T]' Produce a ``TRY_CAST`` expression for backends which support it; [extrait de try_cast.__doc__]
tuple_(*clauses: '_ColumnExpressionArgument[Any]', types: 'Optional[Sequence[_TypeEngineArgument[Any]]]' = None) -> 'Tuple' Return a :class:`.Tuple`. [extrait de tuple_.__doc__]
type_coerce(expression: '_ColumnExpressionOrLiteralArgument[Any]', type_: '_TypeEngineArgument[_T]') -> 'TypeCoerce[_T]' Associate a SQL expression with a particular type, without rendering [extrait de type_coerce.__doc__]
union(*selects: '_SelectStatementForCompoundArgument') -> 'CompoundSelect' Return a ``UNION`` of multiple selectables. [extrait de union.__doc__]
union_all(*selects: '_SelectStatementForCompoundArgument') -> 'CompoundSelect' Return a ``UNION ALL`` of multiple selectables. [extrait de union_all.__doc__]
update(table: '_DMLTableArgument') -> 'Update' Construct an :class:`_expression.Update` object. [extrait de update.__doc__]
values(*columns: 'ColumnClause[Any]', name: 'Optional[str]' = None, literal_binds: 'bool' = False) -> 'Values' Construct a :class:`_expression.Values` construct. [extrait de values.__doc__]
within_group(element: 'FunctionElement[_T]', *order_by: '_ColumnExpressionArgument[Any]') -> 'WithinGroup[_T]' Produce a :class:`.WithinGroup` object against a function. [extrait de within_group.__doc__]

Liste des variables globales du module sqlalchemy

Nom de la variable globale Valeur
annotations _Feature((3, 7, 0, 'beta', 1), None, 16777216)
BLANK_SCHEMA SchemaConst.BLANK_SCHEMA
LABEL_STYLE_DEFAULT SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY
LABEL_STYLE_DISAMBIGUATE_ONLY SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY
LABEL_STYLE_NONE SelectLabelStyle.LABEL_STYLE_NONE
LABEL_STYLE_TABLENAME_PLUS_COL SelectLabelStyle.LABEL_STYLE_TABLENAME_PLUS_COL

Liste des alias du module sqlalchemy

Nom de l'alias Définition ciblée
ColumnExpressionArgument Union
DDLElement ExecutableDDLElement
INT INTEGER
ResultProxy CursorResult
TextAsFrom TextualSelect
nullsfirst nulls_first
nullslast nulls_last


Vous êtes un professionnel et vous avez besoin d'une formation ? Machine Learning
avec Scikit-Learn Voir le programme détaillé



Le tutoriel Python complet (Text+Vidéos)
Le tutoriel Python en vidéos
Evaluez vos compétences en Python