| add_mapped_attribute(target: 'Type[_O]', key: 'str', attr: 'MapperProperty[Any]') -> 'None' |
Add a new mapped attribute to an ORM mapped class. [extrait de add_mapped_attribute.__doc__] |
| aliased(element: 'Union[_EntityType[_O], FromClause]', alias: 'Optional[FromClause]' = None, name: 'Optional[str]' = None, flat: 'bool' = False, adapt_on_names: 'bool' = False) -> 'Union[AliasedClass[_O], FromClause, AliasedType[_O]]' |
Produce an alias of the given element, usually an :class:`.AliasedClass` [extrait de aliased.__doc__] |
| as_declarative(**kw: 'Any') -> 'Callable[[Type[_T]], Type[_T]]' |
|
| attribute_keyed_dict(attr_name: 'str', *, ignore_unpopulated_attribute: 'bool' = False) -> 'Type[KeyFuncDict[Any, Any]]' |
A dictionary-based collection type with attribute-based keying. [extrait de attribute_keyed_dict.__doc__] |
| backref(name: 'str', **kwargs: 'Any') -> 'ORMBackrefArgument' |
When using the :paramref:`_orm.relationship.backref` parameter, [extrait de backref.__doc__] |
| class_mapper(class_: 'Type[_O]', configure: 'bool' = True) -> 'Mapper[_O]' |
Given a class, return the primary :class:`_orm.Mapper` associated [extrait de class_mapper.__doc__] |
| clear_mappers() -> 'None' |
Remove all mappers from all classes. [extrait de clear_mappers.__doc__] |
| close_all_sessions() -> 'None' |
Close all sessions in memory. [extrait de close_all_sessions.__doc__] |
| column_keyed_dict(mapping_spec: 'Union[Type[_KT], Callable[[_KT], _VT]]', *, ignore_unpopulated_attribute: 'bool' = False) -> 'Type[KeyFuncDict[_KT, _KT]]' |
A dictionary-based collection type with column-based keying. [extrait de column_keyed_dict.__doc__] |
| column_property(column: '_ORMColumnExprArgument[_T]', *additional_columns: '_ORMColumnExprArgument[Any]', group: 'Optional[str]' = None, deferred: 'bool' = False, raiseload: 'bool' = False, comparator_factory: 'Optional[Type[PropComparator[_T]]]' = None, init: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, repr: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, default: 'Optional[Any]' = _NoArg.NO_ARG, default_factory: 'Union[_NoArg, Callable[[], _T]]' = _NoArg.NO_ARG, compare: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, kw_only: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, hash: 'Union[_NoArg, bool, None]' = _NoArg.NO_ARG, active_history: 'bool' = False, expire_on_flush: 'bool' = True, info: 'Optional[_InfoType]' = None, doc: 'Optional[str]' = None) -> 'MappedSQLExpression[_T]' |
Provide a column-level property for use with a mapping. [extrait de column_property.__doc__] |
| composite(_class_or_attr: 'Union[None, Type[_CC], Callable[..., _CC], _CompositeAttrType[Any]]' = None, *attrs: '_CompositeAttrType[Any]', group: 'Optional[str]' = None, deferred: 'bool' = False, raiseload: 'bool' = False, comparator_factory: 'Optional[Type[Composite.Comparator[_T]]]' = None, active_history: 'bool' = False, init: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, repr: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, default: 'Optional[Any]' = _NoArg.NO_ARG, default_factory: 'Union[_NoArg, Callable[[], _T]]' = _NoArg.NO_ARG, compare: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, kw_only: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, hash: 'Union[_NoArg, bool, None]' = _NoArg.NO_ARG, info: 'Optional[_InfoType]' = None, doc: 'Optional[str]' = None, **__kw: 'Any') -> 'Composite[Any]' |
Return a composite column-based property for use with a Mapper. [extrait de composite.__doc__] |
| configure_mappers() -> 'None' |
Initialize the inter-mapper relationships of all mappers that [extrait de configure_mappers.__doc__] |
| contains_alias(alias: 'Union[Alias, Subquery]') -> 'AliasOption' |
Return a :class:`.MapperOption` that will indicate to the [extrait de contains_alias.__doc__] |
| contains_eager(*keys: '_AttrType', **kw: 'Any') -> '_AbstractLoad' |
Indicate that the given attribute should be eagerly loaded from [extrait de contains_eager.__doc__] |
| create_session(bind: 'Optional[_SessionBind]' = None, **kwargs: 'Any') -> 'Session' |
Create a new :class:`.Session` [extrait de create_session.__doc__] |
| declarative_base(*, metadata: 'Optional[MetaData]' = None, mapper: 'Optional[Callable[..., Mapper[Any]]]' = None, cls: 'Type[Any]' = <class 'object'>, name: 'str' = 'Base', class_registry: 'Optional[clsregistry._ClsRegistryType]' = None, type_annotation_map: 'Optional[_TypeAnnotationMapType]' = None, constructor: 'Callable[..., None]' = <function _declarative_constructor at 0x0000020DA13BC2C0>, metaclass: 'Type[Any]' = <class 'sqlalchemy.orm.decl_api.DeclarativeMeta'>) -> 'Any' |
Construct a base class for declarative class definitions. [extrait de declarative_base.__doc__] |
| declarative_mixin(cls: 'Type[_T]') -> 'Type[_T]' |
Mark a class as providing the feature of "declarative mixin". [extrait de declarative_mixin.__doc__] |
| defaultload(*keys: '_AttrType') -> '_AbstractLoad' |
Indicate an attribute should load using its predefined loader style. [extrait de defaultload.__doc__] |
| defer(key: '_AttrType', *addl_attrs: '_AttrType', raiseload: 'bool' = False) -> '_AbstractLoad' |
Indicate that the given column-oriented attribute should be [extrait de defer.__doc__] |
| deferred(column: '_ORMColumnExprArgument[_T]', *additional_columns: '_ORMColumnExprArgument[Any]', group: 'Optional[str]' = None, raiseload: 'bool' = False, comparator_factory: 'Optional[Type[PropComparator[_T]]]' = None, init: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, repr: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, default: 'Optional[Any]' = _NoArg.NO_ARG, default_factory: 'Union[_NoArg, Callable[[], _T]]' = _NoArg.NO_ARG, compare: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, kw_only: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, hash: 'Union[_NoArg, bool, None]' = _NoArg.NO_ARG, active_history: 'bool' = False, expire_on_flush: 'bool' = True, info: 'Optional[_InfoType]' = None, doc: 'Optional[str]' = None) -> 'MappedSQLExpression[_T]' |
Indicate a column-based mapped attribute that by default will [extrait de deferred.__doc__] |
| dynamic_loader(argument: 'Optional[_RelationshipArgumentType[Any]]' = None, **kw: 'Any') -> 'RelationshipProperty[Any]' |
Construct a dynamically-loading mapper property. [extrait de dynamic_loader.__doc__] |
| foreign(expr: '_CEA') -> '_CEA' |
Annotate a portion of a primaryjoin expression [extrait de foreign.__doc__] |
| has_inherited_table(cls: 'Type[_O]') -> 'bool' |
Given a class, return True if any of the classes it inherits from has a [extrait de has_inherited_table.__doc__] |
| immediateload(*keys: '_AttrType', recursion_depth: 'Optional[int]' = None) -> '_AbstractLoad' |
Indicate that the given attribute should be loaded using [extrait de immediateload.__doc__] |
| join(left: '_FromClauseArgument', right: '_FromClauseArgument', onclause: 'Optional[_OnClauseArgument]' = None, isouter: 'bool' = False, full: 'bool' = False) -> '_ORMJoin' |
Produce an inner join between left and right clauses. [extrait de join.__doc__] |
| joinedload(*keys: '_AttrType', **kw: 'Any') -> '_AbstractLoad' |
Indicate that the given attribute should be loaded using joined [extrait de joinedload.__doc__] |
| keyfunc_mapping(keyfunc: 'Callable[[Any], Any]', *, ignore_unpopulated_attribute: 'bool' = False) -> 'Type[KeyFuncDict[_KT, Any]]' |
A dictionary-based collection type with arbitrary keying. [extrait de keyfunc_mapping.__doc__] |
| lazyload(*keys: '_AttrType') -> '_AbstractLoad' |
Indicate that the given attribute should be loaded using "lazy" [extrait de lazyload.__doc__] |
| load_only(*attrs: '_AttrType', raiseload: 'bool' = False) -> '_AbstractLoad' |
Indicate that for a particular entity, only the given list [extrait de load_only.__doc__] |
| make_transient(instance: 'object') -> 'None' |
Alter the state of the given instance so that it is :term:`transient`. [extrait de make_transient.__doc__] |
| make_transient_to_detached(instance: 'object') -> 'None' |
Make the given transient instance :term:`detached`. [extrait de make_transient_to_detached.__doc__] |
| mapped_column(__name_pos: 'Optional[Union[str, _TypeEngineArgument[Any], SchemaEventTarget]]' = None, __type_pos: 'Optional[Union[_TypeEngineArgument[Any], SchemaEventTarget]]' = None, *args: 'SchemaEventTarget', init: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, repr: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, default: 'Optional[Any]' = _NoArg.NO_ARG, default_factory: 'Union[_NoArg, Callable[[], _T]]' = _NoArg.NO_ARG, compare: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, kw_only: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, hash: 'Union[_NoArg, bool, None]' = _NoArg.NO_ARG, nullable: 'Optional[Union[bool, Literal[SchemaConst.NULL_UNSPECIFIED]]]' = <SchemaConst.NULL_UNSPECIFIED: 3>, primary_key: 'Optional[bool]' = False, deferred: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, deferred_group: 'Optional[str]' = None, deferred_raiseload: 'Optional[bool]' = None, use_existing_column: 'bool' = False, name: 'Optional[str]' = None, type_: 'Optional[_TypeEngineArgument[Any]]' = None, autoincrement: '_AutoIncrementType' = 'auto', doc: 'Optional[str]' = None, key: 'Optional[str]' = None, index: 'Optional[bool]' = None, unique: 'Optional[bool]' = None, info: 'Optional[_InfoType]' = None, onupdate: 'Optional[Any]' = None, insert_default: 'Optional[Any]' = _NoArg.NO_ARG, server_default: 'Optional[_ServerDefaultArgument]' = None, server_onupdate: 'Optional[_ServerOnUpdateArgument]' = None, active_history: 'bool' = False, quote: 'Optional[bool]' = None, system: 'bool' = False, comment: 'Optional[str]' = None, sort_order: 'Union[_NoArg, int]' = _NoArg.NO_ARG, **kw: 'Any') -> 'MappedColumn[Any]' |
declare a new ORM-mapped :class:`_schema.Column` construct [extrait de mapped_column.__doc__] |
| merge_frozen_result(session, statement, frozen_result, load=True) |
Merge a :class:`_engine.FrozenResult` back into a :class:`_orm.Session`, [extrait de merge_frozen_result.__doc__] |
| merge_result(query: 'Query[Any]', iterator: 'Union[FrozenResult, Iterable[Sequence[Any]], Iterable[object]]', load: 'bool' = True) -> 'Union[FrozenResult, Iterable[Any]]' |
Merge a result into the given :class:`.Query` object's Session. [extrait de merge_result.__doc__] |
| noload(*keys: '_AttrType') -> '_AbstractLoad' |
Indicate that the given relationship attribute should remain [extrait de noload.__doc__] |
| object_mapper(instance: '_T') -> 'Mapper[_T]' |
Given an object, return the primary Mapper associated with the object [extrait de object_mapper.__doc__] |
| object_session(instance: 'object') -> 'Optional[Session]' |
Return the :class:`.Session` to which the given instance belongs. [extrait de object_session.__doc__] |
| orm_insert_sentinel(name: 'Optional[str]' = None, type_: 'Optional[_TypeEngineArgument[Any]]' = None, *, default: 'Optional[Any]' = None, omit_from_statements: 'bool' = True) -> 'MappedColumn[Any]' |
Provides a surrogate :func:`_orm.mapped_column` that generates [extrait de orm_insert_sentinel.__doc__] |
| outerjoin(left: '_FromClauseArgument', right: '_FromClauseArgument', onclause: 'Optional[_OnClauseArgument]' = None, full: 'bool' = False) -> '_ORMJoin' |
Produce a left outer join between left and right clauses. [extrait de outerjoin.__doc__] |
| polymorphic_union(table_map, typecolname, aliasname='p_union', cast_nulls=True) |
Create a ``UNION`` statement used by a polymorphic mapper. [extrait de polymorphic_union.__doc__] |
| query_expression(default_expr: '_ORMColumnExprArgument[_T]' = <sqlalchemy.sql.elements.Null object at 0x0000020D9F6F8440>, *, repr: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, compare: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, expire_on_flush: 'bool' = True, info: 'Optional[_InfoType]' = None, doc: 'Optional[str]' = None) -> 'MappedSQLExpression[_T]' |
Indicate an attribute that populates from a query-time SQL expression. [extrait de query_expression.__doc__] |
| raiseload(*keys: '_AttrType', **kw: 'Any') -> '_AbstractLoad' |
Indicate that the given attribute should raise an error if accessed. [extrait de raiseload.__doc__] |
| reconstructor(fn) |
Decorate a method as the 'reconstructor' hook. [extrait de reconstructor.__doc__] |
| relationship(argument: 'Optional[_RelationshipArgumentType[Any]]' = None, secondary: 'Optional[_RelationshipSecondaryArgument]' = None, *, uselist: 'Optional[bool]' = None, collection_class: 'Optional[Union[Type[Collection[Any]], Callable[[], Collection[Any]]]]' = None, primaryjoin: 'Optional[_RelationshipJoinConditionArgument]' = None, secondaryjoin: 'Optional[_RelationshipJoinConditionArgument]' = None, back_populates: 'Optional[str]' = None, order_by: '_ORMOrderByArgument' = False, backref: 'Optional[ORMBackrefArgument]' = None, overlaps: 'Optional[str]' = None, post_update: 'bool' = False, cascade: 'str' = 'save-update, merge', viewonly: 'bool' = False, init: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, repr: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, default: 'Union[_NoArg, _T]' = _NoArg.NO_ARG, default_factory: 'Union[_NoArg, Callable[[], _T]]' = _NoArg.NO_ARG, compare: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, kw_only: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, hash: 'Union[_NoArg, bool, None]' = _NoArg.NO_ARG, lazy: '_LazyLoadArgumentType' = 'select', passive_deletes: "Union[Literal['all'], bool]" = False, passive_updates: 'bool' = True, active_history: 'bool' = False, enable_typechecks: 'bool' = True, foreign_keys: 'Optional[_ORMColCollectionArgument]' = None, remote_side: 'Optional[_ORMColCollectionArgument]' = None, join_depth: 'Optional[int]' = None, comparator_factory: 'Optional[Type[RelationshipProperty.Comparator[Any]]]' = None, single_parent: 'bool' = False, innerjoin: 'bool' = False, distinct_target_key: 'Optional[bool]' = None, load_on_pending: 'bool' = False, query_class: 'Optional[Type[Query[Any]]]' = None, info: 'Optional[_InfoType]' = None, omit_join: 'Literal[None, False]' = None, sync_backref: 'Optional[bool]' = None, **kw: 'Any') -> '_RelationshipDeclared[Any]' |
Provide a relationship between two mapped classes. [extrait de relationship.__doc__] |
| remote(expr: '_CEA') -> '_CEA' |
Annotate a portion of a primaryjoin expression [extrait de remote.__doc__] |
| selectin_polymorphic(base_cls: '_EntityType[Any]', classes: 'Iterable[Type[Any]]') -> '_AbstractLoad' |
Indicate an eager load should take place for all attributes [extrait de selectin_polymorphic.__doc__] |
| selectinload(*keys: '_AttrType', recursion_depth: 'Optional[int]' = None) -> '_AbstractLoad' |
Indicate that the given attribute should be loaded using [extrait de selectinload.__doc__] |
| subqueryload(*keys: '_AttrType') -> '_AbstractLoad' |
Indicate that the given attribute should be loaded using [extrait de subqueryload.__doc__] |
| synonym(name: 'str', *, map_column: 'Optional[bool]' = None, descriptor: 'Optional[Any]' = None, comparator_factory: 'Optional[Type[PropComparator[_T]]]' = None, init: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, repr: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, default: 'Union[_NoArg, _T]' = _NoArg.NO_ARG, default_factory: 'Union[_NoArg, Callable[[], _T]]' = _NoArg.NO_ARG, compare: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, kw_only: 'Union[_NoArg, bool]' = _NoArg.NO_ARG, hash: 'Union[_NoArg, bool, None]' = _NoArg.NO_ARG, info: 'Optional[_InfoType]' = None, doc: 'Optional[str]' = None) -> 'Synonym[Any]' |
Denote an attribute name as a synonym to a mapped property, [extrait de synonym.__doc__] |
| synonym_for(name: 'str', map_column: 'bool' = False) -> 'Callable[[Callable[..., Any]], Synonym[Any]]' |
Decorator that produces an :func:`_orm.synonym` [extrait de synonym_for.__doc__] |
| undefer(key: '_AttrType', *addl_attrs: '_AttrType') -> '_AbstractLoad' |
Indicate that the given column-oriented attribute should be [extrait de undefer.__doc__] |
| undefer_group(name: 'str') -> '_AbstractLoad' |
Indicate that columns within the given deferred group name should be [extrait de undefer_group.__doc__] |
| validates(*names: 'str', include_removes: 'bool' = False, include_backrefs: 'bool' = True) -> 'Callable[[_Fn], _Fn]' |
Decorate a method as a 'validator' for one or more named properties. [extrait de validates.__doc__] |
| was_deleted(object_: 'object') -> 'bool' |
Return True if the given object was deleted [extrait de was_deleted.__doc__] |
| with_expression(key: '_AttrType', expression: '_ColumnExpressionArgument[Any]') -> '_AbstractLoad' |
Apply an ad-hoc SQL expression to a "deferred expression" [extrait de with_expression.__doc__] |
| with_loader_criteria(entity_or_base: '_EntityType[Any]', where_criteria: 'Union[_ColumnExpressionArgument[bool], Callable[[Any], _ColumnExpressionArgument[bool]]]', loader_only: 'bool' = False, include_aliases: 'bool' = False, propagate_to_loaders: 'bool' = True, track_closure_variables: 'bool' = True) -> 'LoaderCriteriaOption' |
Add additional WHERE criteria to the load for all occurrences of [extrait de with_loader_criteria.__doc__] |
| with_parent(instance: 'object', prop: 'attributes.QueryableAttribute[Any]', from_entity: 'Optional[_EntityType[Any]]' = None) -> 'ColumnElement[bool]' |
Create filtering criterion that relates this query's primary entity [extrait de with_parent.__doc__] |
| with_polymorphic(base: 'Union[Type[_O], Mapper[_O]]', classes: "Union[Literal['*'], Iterable[Type[Any]]]", selectable: 'Union[Literal[False, None], FromClause]' = False, flat: 'bool' = False, polymorphic_on: 'Optional[ColumnElement[Any]]' = None, aliased: 'bool' = False, innerjoin: 'bool' = False, adapt_on_names: 'bool' = False, name: 'Optional[str]' = None, _use_mapper_path: 'bool' = False) -> 'AliasedClass[_O]' |
Produce an :class:`.AliasedClass` construct which specifies [extrait de with_polymorphic.__doc__] |
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 :