From: Mike Bayer Date: Tue, 15 Jan 2019 15:49:36 +0000 (-0500) Subject: Remove version directives for 0.6, 0.7, 0.8 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=084c8a38066ea0b35aca19075079fc725b149641;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git Remove version directives for 0.6, 0.7, 0.8 - fix a few "seealso"s - ComparableProprerty's "superseded in 0.7" becomes deprecated in 0.7 Backport to currently maintained doc versions 1.2, 1.1 Change-Id: Ib1fcb2df8673dbe5c4ffc47f3896a60d1dfcb4b2 (cherry picked from commit 885f15a306efc4c907ca82fa13871992ee556466) (cherry picked from commit 996eb2d4bf7dcff57e4d47d467e8252ced5fe13d) --- diff --git a/doc/build/core/connections.rst b/doc/build/core/connections.rst index 29e884396e..aacb537f5d 100644 --- a/doc/build/core/connections.rst +++ b/doc/build/core/connections.rst @@ -708,7 +708,6 @@ the need for separate installation. Use the ``register()`` function as follows The above will respond to ``create_engine("mysql+foodialect://")`` and load the ``MyMySQLDialect`` class from the ``myapp.dialect`` module. -.. versionadded:: 0.8 Connection / Engine API ======================= diff --git a/doc/build/core/constraints.rst b/doc/build/core/constraints.rst index 74ac187232..0415438a0e 100644 --- a/doc/build/core/constraints.rst +++ b/doc/build/core/constraints.rst @@ -812,10 +812,6 @@ identify columns:: Index('idx_col34', 'col3', 'col4', unique=True) ) -.. versionadded:: 0.7 - Support of "inline" definition inside the :class:`.Table` - for :class:`.Index`\ . - The :class:`~sqlalchemy.schema.Index` object also supports its own ``create()`` method: .. sourcecode:: python+sql @@ -844,9 +840,6 @@ a "case insensitive" index can be created using the ``lower()`` function:: Index('someindex', func.lower(mytable.c.somecol)) -.. versionadded:: 0.8 :class:`.Index` supports SQL expressions and functions - as well as plain columns. - Index API --------- diff --git a/doc/build/core/custom_types.rst b/doc/build/core/custom_types.rst index e85601f172..6bbc8fbbc3 100644 --- a/doc/build/core/custom_types.rst +++ b/doc/build/core/custom_types.rst @@ -459,12 +459,9 @@ to the INSERT and SELECT statements:: {'pgp_sym_decrypt_1': 'this is my passphrase', 'username_1': 'some user'} -.. versionadded:: 0.8 Added the :meth:`.TypeEngine.bind_expression` and - :meth:`.TypeEngine.column_expression` methods. - -See also: +.. seealso:: -:ref:`examples_postgis` + :ref:`examples_postgis` .. _types_operators: diff --git a/doc/build/core/event.rst b/doc/build/core/event.rst index 018a46cd7d..6e53ae3b96 100644 --- a/doc/build/core/event.rst +++ b/doc/build/core/event.rst @@ -6,10 +6,6 @@ Events SQLAlchemy includes an event API which publishes a wide variety of hooks into the internals of both SQLAlchemy Core and ORM. -.. versionadded:: 0.7 - The system supersedes the previous system of "extension", "proxy", - and "listener" classes. - Event Registration ------------------ diff --git a/doc/build/core/tutorial.rst b/doc/build/core/tutorial.rst index e7fe4966b9..9f751d50fb 100644 --- a/doc/build/core/tutorial.rst +++ b/doc/build/core/tutorial.rst @@ -2009,8 +2009,6 @@ table, or the same table: Multiple Table Updates ---------------------- -.. versionadded:: 0.7.4 - The PostgreSQL, Microsoft SQL Server, and MySQL backends all support UPDATE statements that refer to multiple tables. For PG and MSSQL, this is the "UPDATE FROM" syntax, which updates one table at a time, but can reference additional tables in an additional diff --git a/doc/build/orm/composites.rst b/doc/build/orm/composites.rst index 71b1294330..5cd86d99aa 100644 --- a/doc/build/orm/composites.rst +++ b/doc/build/orm/composites.rst @@ -115,11 +115,6 @@ via the usage of the :class:`.MutableComposite` mixin, which uses events to associate each user-defined composite object with all parent associations. Please see the example in :ref:`mutable_composites`. -.. versionchanged:: 0.7 - In-place changes to an existing composite value are no longer - tracked automatically; the functionality is superseded by the - :class:`.MutableComposite` class. - .. _composite_operations: Redefining Comparison Operations for Composites @@ -227,4 +222,4 @@ We can then use the above mapping as:: hv = s.query(HasVertex).filter( HasVertex.vertex == Vertex(Point(1, 2), Point(3, 4))).first() print(hv.vertex.start) - print(hv.vertex.end) \ No newline at end of file + print(hv.vertex.end) diff --git a/doc/build/orm/extensions/associationproxy.rst b/doc/build/orm/extensions/associationproxy.rst index 18803c75ff..b2b5a4cb45 100644 --- a/doc/build/orm/extensions/associationproxy.rst +++ b/doc/build/orm/extensions/associationproxy.rst @@ -484,9 +484,6 @@ using the :attr:`~.AssociationProxy.attr` attribute in a star-args context:: q = session.query(User).join(*User.keywords.attr) -.. versionadded:: 0.7.3 - :attr:`~.AssociationProxy.attr` attribute in a star-args context. - :attr:`~.AssociationProxy.attr` is composed of :attr:`.AssociationProxy.local_attr` and :attr:`.AssociationProxy.remote_attr`, which are just synonyms for the actual proxied attributes, and can also be used for querying:: @@ -497,10 +494,6 @@ be used for querying:: join(uka, User.keywords.local_attr).\ join(ka, User.keywords.remote_attr) -.. versionadded:: 0.7.3 - :attr:`.AssociationProxy.local_attr` and :attr:`.AssociationProxy.remote_attr`, - synonyms for the actual proxied attributes, and usable for querying. - API Documentation ----------------- diff --git a/doc/build/orm/extensions/declarative/inheritance.rst b/doc/build/orm/extensions/declarative/inheritance.rst index 25ce986b7d..7f5ef63fa5 100644 --- a/doc/build/orm/extensions/declarative/inheritance.rst +++ b/doc/build/orm/extensions/declarative/inheritance.rst @@ -158,19 +158,6 @@ inheritance without fixing ``start_date``), an error is raised which indicates an existing :class:`.Column` is trying to be re-assigned to a different owning :class:`.Table`. -.. versionadded:: 0.8 :class:`.declared_attr` can be used on a non-mixin - class, and the returned :class:`.Column` or other mapped attribute - will be applied to the mapping as any other attribute. Previously, - the resulting attribute would be ignored, and also result in a warning - being emitted when a subclass was created. - -.. versionadded:: 0.8 :class:`.declared_attr`, when used either with a - mixin or non-mixin declarative class, can return an existing - :class:`.Column` already assigned to the parent :class:`.Table`, - to indicate that the re-assignment of the :class:`.Column` should be - skipped, however should still be mapped on the target class, - in order to resolve duplicate column conflicts. - The same concept can be used with mixin classes (see :ref:`declarative_mixins`):: diff --git a/doc/build/orm/extensions/declarative/mixins.rst b/doc/build/orm/extensions/declarative/mixins.rst index 3b1146240c..0c6662537b 100644 --- a/doc/build/orm/extensions/declarative/mixins.rst +++ b/doc/build/orm/extensions/declarative/mixins.rst @@ -138,9 +138,6 @@ point at which the ``User`` class is constructed, and the declarative extension can use the resulting :class:`.Column` object as returned by the method without the need to copy it. -.. versionchanged:: 0.6.5 Rename ``sqlalchemy.util.classproperty`` - into :class:`~.declared_attr`. - Columns generated by :class:`~.declared_attr` can also be referenced by ``__mapper_args__`` to a limited degree, currently by ``polymorphic_on`` and ``version_id_col``; the declarative extension @@ -366,10 +363,6 @@ When constructing the :func:`.association_proxy`, the :func:`.association_proxy` object is created for each of the ``TypeA`` and ``TypeB`` classes. -.. versionadded:: 0.8 :class:`.declared_attr` is usable with non-mapped - attributes, including user-defined attributes as well as - :func:`.association_proxy`. - .. _decl_mixin_inheritance: Controlling table inheritance with mixins diff --git a/doc/build/orm/extensions/declarative/relationships.rst b/doc/build/orm/extensions/declarative/relationships.rst index 66eff40dfb..1763344c76 100644 --- a/doc/build/orm/extensions/declarative/relationships.rst +++ b/doc/build/orm/extensions/declarative/relationships.rst @@ -82,10 +82,6 @@ we can specify ``address.Address`` or ``lookup.Address``:: primaryjoin="address.Address.user_id==" "User.id") -.. versionadded:: 0.8 - module-qualified paths can be used when specifying string arguments - with Declarative, in order to specify specific modules. - Two alternatives also exist to using string-based attributes. A lambda can also be used, which will be evaluated after all mappers have been configured:: diff --git a/doc/build/orm/extensions/declarative/table_config.rst b/doc/build/orm/extensions/declarative/table_config.rst index a14deb6aa6..d2ae572b2e 100644 --- a/doc/build/orm/extensions/declarative/table_config.rst +++ b/doc/build/orm/extensions/declarative/table_config.rst @@ -146,5 +146,3 @@ only after a special ``prepare(engine)`` step is called:: Base.prepare(e) -.. versionadded:: 0.8 - Added :class:`.DeferredReflection`. diff --git a/doc/build/orm/internals.rst b/doc/build/orm/internals.rst index debb1ab7e2..a8d2d6aafb 100644 --- a/doc/build/orm/internals.rst +++ b/doc/build/orm/internals.rst @@ -66,9 +66,6 @@ sections, are listed here. :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. - .. versionadded:: 0.8 Added support for .info to all - :class:`.MapperProperty` subclasses. - .. versionchanged:: 1.0.0 :attr:`.InspectionAttr.info` moved from :class:`.MapperProperty` so that it can apply to a wider variety of ORM and extension constructs. diff --git a/doc/build/orm/join_conditions.rst b/doc/build/orm/join_conditions.rst index 9044f2acaf..f54d2c0495 100644 --- a/doc/build/orm/join_conditions.rst +++ b/doc/build/orm/join_conditions.rst @@ -96,11 +96,6 @@ one :class:`.Column` we need:: billing_address = relationship("Address", foreign_keys="Customer.billing_address_id") -.. versionchanged:: 0.8 - :func:`.relationship` can resolve ambiguity between foreign key targets on the - basis of the ``foreign_keys`` argument alone; the :paramref:`~.relationship.primaryjoin` - argument is no longer needed in this situation. - .. _relationship_primaryjoin: Specifying Alternate Join Conditions diff --git a/doc/build/orm/self_referential.rst b/doc/build/orm/self_referential.rst index a3b288d5cd..b87b87dac0 100644 --- a/doc/build/orm/self_referential.rst +++ b/doc/build/orm/self_referential.rst @@ -114,10 +114,6 @@ is on both sides, and aligns the "remote" column along with the ``folder_id`` column, which it recognizes as uniquely present on the "remote" side. -.. versionadded:: 0.8 - Support for self-referential composite keys in :func:`.relationship` - where a column points to itself. - Self-Referential Query Strategies ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/lib/sqlalchemy/dialects/firebird/fdb.py b/lib/sqlalchemy/dialects/firebird/fdb.py index e8da6e1b73..5625d62367 100644 --- a/lib/sqlalchemy/dialects/firebird/fdb.py +++ b/lib/sqlalchemy/dialects/firebird/fdb.py @@ -15,8 +15,6 @@ fdb is a kinterbasdb compatible DBAPI for Firebird. - .. versionadded:: 0.8 - Support for the fdb Firebird driver. - .. versionchanged:: 0.9 - The fdb dialect is now the default dialect under the ``firebird://`` URL space, as ``fdb`` is now the official Python driver for Firebird. @@ -54,10 +52,6 @@ accept every argument that Kinterbasdb does. Please read the fdb and/or kinterbasdb DBAPI documentation in order to understand the implications of this flag. - .. versionadded:: 0.8.2 - ``retaining`` keyword argument specifying - transaction retaining behavior - in 0.8 it defaults to ``True`` - for backwards compatibility. - .. versionchanged:: 0.9.0 - the ``retaining`` flag defaults to ``False``. In 0.8 it defaulted to ``True``. diff --git a/lib/sqlalchemy/dialects/mssql/base.py b/lib/sqlalchemy/dialects/mssql/base.py index c1d93cf2e7..372697948f 100644 --- a/lib/sqlalchemy/dialects/mssql/base.py +++ b/lib/sqlalchemy/dialects/mssql/base.py @@ -200,9 +200,6 @@ CREATE TABLE statement for this column will yield:: login VARCHAR(32) COLLATE Latin1_General_CI_AS NULL -.. versionadded:: 0.8 Character collations are now part of the base string - types. - LIMIT/OFFSET Support -------------------- @@ -439,8 +436,6 @@ names:: would render the index as ``CREATE INDEX my_index ON table (x) INCLUDE (y)`` -.. versionadded:: 0.8 - Index ordering ^^^^^^^^^^^^^^ @@ -450,8 +445,6 @@ Index ordering is available via functional expressions, such as:: would render the index as ``CREATE INDEX my_index ON table (x DESC)`` -.. versionadded:: 0.8 - .. seealso:: :ref:`schema_indexes_functional` diff --git a/lib/sqlalchemy/dialects/mysql/base.py b/lib/sqlalchemy/dialects/mysql/base.py index 7a050699a3..08e7c7bf0e 100644 --- a/lib/sqlalchemy/dialects/mysql/base.py +++ b/lib/sqlalchemy/dialects/mysql/base.py @@ -302,9 +302,6 @@ into play when rendering table and column names as well as when reflecting existing database structures. The detection is entirely automatic and no special configuration is needed to use either quoting style. -.. versionchanged:: 0.6 detection of ANSI quoting style is entirely automatic, - there's no longer any end-user ``create_engine()`` options in this regard. - MySQL SQL Extensions -------------------- @@ -401,9 +398,6 @@ prefix length values for corresponding columns. MySQL only allows a length for a column of an index if it is for a CHAR, VARCHAR, TEXT, BINARY, VARBINARY and BLOB. -.. versionadded:: 0.8.2 ``mysql_length`` may now be specified as a dictionary - for use with composite indexes. - Index Prefixes ~~~~~~~~~~~~~~ diff --git a/lib/sqlalchemy/dialects/mysql/gaerdbms.py b/lib/sqlalchemy/dialects/mysql/gaerdbms.py index 806e4c8745..a1db14cd62 100644 --- a/lib/sqlalchemy/dialects/mysql/gaerdbms.py +++ b/lib/sqlalchemy/dialects/mysql/gaerdbms.py @@ -15,8 +15,6 @@ developers-guide This dialect is based primarily on the :mod:`.mysql.mysqldb` dialect with minimal changes. - .. versionadded:: 0.7.8 - .. deprecated:: 1.0 This dialect is **no longer necessary** for Google Cloud SQL; the MySQLdb dialect can be used directly. Cloud SQL now recommends creating connections via the diff --git a/lib/sqlalchemy/dialects/mysql/types.py b/lib/sqlalchemy/dialects/mysql/types.py index cb09a0841e..3310110fa3 100644 --- a/lib/sqlalchemy/dialects/mysql/types.py +++ b/lib/sqlalchemy/dialects/mysql/types.py @@ -397,9 +397,6 @@ class TIME(sqltypes.TIME): be limited; current support includes MySQL Connector/Python. - .. versionadded:: 0.8 The MySQL-specific TIME - type as well as fractional seconds support. - """ super(TIME, self).__init__(timezone=timezone) self.fsp = fsp @@ -444,9 +441,6 @@ class TIMESTAMP(sqltypes.TIMESTAMP): be limited; current support includes MySQL Connector/Python. - .. versionadded:: 0.8.5 Added MySQL-specific :class:`.mysql.TIMESTAMP` - with fractional seconds support. - """ super(TIMESTAMP, self).__init__(timezone=timezone) self.fsp = fsp @@ -474,9 +468,6 @@ class DATETIME(sqltypes.DATETIME): be limited; current support includes MySQL Connector/Python. - .. versionadded:: 0.8.5 Added MySQL-specific :class:`.mysql.DATETIME` - with fractional seconds support. - """ super(DATETIME, self).__init__(timezone=timezone) self.fsp = fsp diff --git a/lib/sqlalchemy/dialects/postgresql/array.py b/lib/sqlalchemy/dialects/postgresql/array.py index 19e075a45d..8c0582db2f 100644 --- a/lib/sqlalchemy/dialects/postgresql/array.py +++ b/lib/sqlalchemy/dialects/postgresql/array.py @@ -71,11 +71,9 @@ class array(expression.Tuple): array(['foo', 'bar'], type_=CHAR) - .. versionadded:: 0.8 Added the :class:`~.postgresql.array` literal type. - - See also: + .. seealso:: - :class:`.postgresql.ARRAY` + :class:`.postgresql.ARRAY` """ __visit_name__ = 'array' diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py index 5783f0db9d..88dd061e93 100644 --- a/lib/sqlalchemy/dialects/postgresql/base.py +++ b/lib/sqlalchemy/dialects/postgresql/base.py @@ -1218,8 +1218,6 @@ class ENUM(sqltypes.Enum): :meth:`~.postgresql.ENUM.drop` methods can be used to emit SQL to a target bind. - .. versionadded:: 0.7.4 - """ self.create_type = kw.pop("create_type", True) super(ENUM, self).__init__(*enums, **kw) diff --git a/lib/sqlalchemy/dialects/postgresql/hstore.py b/lib/sqlalchemy/dialects/postgresql/hstore.py index b6c9e7124c..e57bcec6e4 100644 --- a/lib/sqlalchemy/dialects/postgresql/hstore.py +++ b/lib/sqlalchemy/dialects/postgresql/hstore.py @@ -113,8 +113,6 @@ class HSTORE(sqltypes.Indexable, sqltypes.Concatenable, sqltypes.TypeEngine): dictionary, unless that dictionary value is re-assigned to the HSTORE-attribute itself, thus generating a change event. - .. versionadded:: 0.8 - .. seealso:: :class:`.hstore` - render the PostgreSQL ``hstore()`` function. @@ -272,8 +270,6 @@ class hstore(sqlfunc.GenericFunction): ) ]) - .. versionadded:: 0.8 - .. seealso:: :class:`.HSTORE` - the PostgreSQL ``HSTORE`` datatype. diff --git a/lib/sqlalchemy/dialects/postgresql/psycopg2.py b/lib/sqlalchemy/dialects/postgresql/psycopg2.py index f796ab497f..9cb08f7c5e 100644 --- a/lib/sqlalchemy/dialects/postgresql/psycopg2.py +++ b/lib/sqlalchemy/dialects/postgresql/psycopg2.py @@ -246,9 +246,6 @@ The psycopg2 dialect supports these constants for isolation level: * ``SERIALIZABLE`` * ``AUTOCOMMIT`` -.. versionadded:: 0.8.2 support for AUTOCOMMIT isolation level when using - psycopg2. - .. seealso:: :ref:`postgresql_isolation_level` diff --git a/lib/sqlalchemy/dialects/postgresql/ranges.py b/lib/sqlalchemy/dialects/postgresql/ranges.py index 38bfb37d44..090d30cef1 100644 --- a/lib/sqlalchemy/dialects/postgresql/ranges.py +++ b/lib/sqlalchemy/dialects/postgresql/ranges.py @@ -24,8 +24,6 @@ class RangeOperators(object): Table 9-45 of the postgres documentation. For these, the normal :func:`~sqlalchemy.sql.expression.func` object should be used. - .. versionadded:: 0.8.2 Support for PostgreSQL RANGE operations. - """ class comparator_factory(sqltypes.Concatenable.Comparator): @@ -99,8 +97,6 @@ class RangeOperators(object): class INT4RANGE(RangeOperators, sqltypes.TypeEngine): """Represent the PostgreSQL INT4RANGE type. - .. versionadded:: 0.8.2 - """ __visit_name__ = 'INT4RANGE' @@ -111,8 +107,6 @@ ischema_names['int4range'] = INT4RANGE class INT8RANGE(RangeOperators, sqltypes.TypeEngine): """Represent the PostgreSQL INT8RANGE type. - .. versionadded:: 0.8.2 - """ __visit_name__ = 'INT8RANGE' @@ -123,8 +117,6 @@ ischema_names['int8range'] = INT8RANGE class NUMRANGE(RangeOperators, sqltypes.TypeEngine): """Represent the PostgreSQL NUMRANGE type. - .. versionadded:: 0.8.2 - """ __visit_name__ = 'NUMRANGE' @@ -135,8 +127,6 @@ ischema_names['numrange'] = NUMRANGE class DATERANGE(RangeOperators, sqltypes.TypeEngine): """Represent the PostgreSQL DATERANGE type. - .. versionadded:: 0.8.2 - """ __visit_name__ = 'DATERANGE' @@ -147,8 +137,6 @@ ischema_names['daterange'] = DATERANGE class TSRANGE(RangeOperators, sqltypes.TypeEngine): """Represent the PostgreSQL TSRANGE type. - .. versionadded:: 0.8.2 - """ __visit_name__ = 'TSRANGE' @@ -159,8 +147,6 @@ ischema_names['tsrange'] = TSRANGE class TSTZRANGE(RangeOperators, sqltypes.TypeEngine): """Represent the PostgreSQL TSTZRANGE type. - .. versionadded:: 0.8.2 - """ __visit_name__ = 'TSTZRANGE' diff --git a/lib/sqlalchemy/dialects/sqlite/pysqlite.py b/lib/sqlalchemy/dialects/sqlite/pysqlite.py index a5e84f7bcd..c873d8884a 100644 --- a/lib/sqlalchemy/dialects/sqlite/pysqlite.py +++ b/lib/sqlalchemy/dialects/sqlite/pysqlite.py @@ -135,12 +135,6 @@ SQLAlchemy sets up pooling to work with Pysqlite's default behavior: necessary. The scheme also prevents a connection from being used again in a different thread and works best with SQLite's coarse-grained file locking. - .. versionchanged:: 0.7 - Default selection of :class:`.NullPool` for SQLite file-based databases. - Previous versions select :class:`.SingletonThreadPool` by - default for all SQLite databases. - - Using a Memory Database in Multiple Threads ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/lib/sqlalchemy/engine/__init__.py b/lib/sqlalchemy/engine/__init__.py index d1a9382925..3922f727f8 100644 --- a/lib/sqlalchemy/engine/__init__.py +++ b/lib/sqlalchemy/engine/__init__.py @@ -147,10 +147,6 @@ def create_engine(*args, **kwargs): will match in a case-insensitive fashion, that is, ``row['SomeColumn']``. - .. versionchanged:: 0.8 - By default, result row names match case-sensitively. - In version 0.7 and prior, all matches were case-insensitive. - :param connect_args: a dictionary of options which will be passed directly to the DBAPI's ``connect()`` method as additional keyword arguments. See the example diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py index aec21604be..95b69ed3ea 100644 --- a/lib/sqlalchemy/engine/base.py +++ b/lib/sqlalchemy/engine/base.py @@ -289,8 +289,6 @@ class Connection(Connectable): or piped into a script that's later invoked by command line tools. - .. versionadded:: 0.7.6 - :param stream_results: Available on: Connection, statement. Indicate to the dialect that results should be "streamed" and not pre-buffered, if possible. This is a limitation @@ -1853,8 +1851,6 @@ class Engine(Connectable, log.Identified): cursor.execute("use %s" % shards[shard_id]) conn.info["current_shard"] = shard_id - .. versionadded:: 0.8 - .. seealso:: :meth:`.Connection.execution_options` - update execution options @@ -1967,15 +1963,13 @@ class Engine(Connectable, log.Identified): :meth:`.Connection.execute` will close the :class:`.Connection` when that :class:`.ResultProxy` has exhausted all result rows. - .. versionadded:: 0.7.6 - - See also: + .. seealso:: - :meth:`.Engine.connect` - procure a :class:`.Connection` from - an :class:`.Engine`. + :meth:`.Engine.connect` - procure a :class:`.Connection` from + an :class:`.Engine`. - :meth:`.Connection.begin` - start a :class:`.Transaction` - for a particular :class:`.Connection`. + :meth:`.Connection.begin` - start a :class:`.Transaction` + for a particular :class:`.Connection`. """ conn = self.contextual_connect(close_with_result=close_with_result) diff --git a/lib/sqlalchemy/engine/interfaces.py b/lib/sqlalchemy/engine/interfaces.py index 551c360930..f560c4b466 100644 --- a/lib/sqlalchemy/engine/interfaces.py +++ b/lib/sqlalchemy/engine/interfaces.py @@ -539,8 +539,6 @@ class Dialect(object): detached from the pool, or is being returned beyond the normal capacity of the pool. - .. versionadded:: 0.8 - """ raise NotImplementedError() diff --git a/lib/sqlalchemy/engine/reflection.py b/lib/sqlalchemy/engine/reflection.py index 671d77cd03..6e2f0dd944 100644 --- a/lib/sqlalchemy/engine/reflection.py +++ b/lib/sqlalchemy/engine/reflection.py @@ -185,12 +185,6 @@ class Inspector(object): more comprehensive solution to resolving foreign key cycles between tables. - .. versionchanged:: 0.8 the "foreign_key" sorting sorts tables - in order of dependee to dependent; that is, in creation - order, rather than in drop order. This is to maintain - consistency with similar features such as - :attr:`.MetaData.sorted_tables` and :func:`.util.sort_tables`. - .. seealso:: :meth:`.Inspector.get_sorted_table_and_fkc_names` @@ -506,8 +500,6 @@ class Inspector(object): of the database connection. For special quoting, use :class:`.quoted_name`. - .. versionadded:: 0.8.4 - """ return self.dialect.get_unique_constraints( diff --git a/lib/sqlalchemy/events.py b/lib/sqlalchemy/events.py index b33b844a34..cd7db41107 100644 --- a/lib/sqlalchemy/events.py +++ b/lib/sqlalchemy/events.py @@ -425,8 +425,6 @@ class PoolEvents(event.Events): :param connection_record: the :class:`._ConnectionRecord` managing the DBAPI connection. - .. versionadded:: 0.8 - .. seealso:: :meth:`.ConnectionEvents.rollback` @@ -589,10 +587,6 @@ class ConnectionEvents(event.Events): and parameters. See those methods for a description of specific return arguments. - .. versionchanged:: 0.8 :class:`.ConnectionEvents` can now be associated - with any :class:`.Connectable` including :class:`.Connection`, - in addition to the existing support for :class:`.Engine`. - """ _target_class_doc = "SomeEngine" diff --git a/lib/sqlalchemy/exc.py b/lib/sqlalchemy/exc.py index e842939c5f..6716ff584e 100644 --- a/lib/sqlalchemy/exc.py +++ b/lib/sqlalchemy/exc.py @@ -93,9 +93,6 @@ class CompileError(SQLAlchemyError): class UnsupportedCompilationError(CompileError): """Raised when an operation is not supported by the given compiler. - - .. versionadded:: 0.8.3 - """ def __init__(self, compiler, element_type): diff --git a/lib/sqlalchemy/ext/declarative/api.py b/lib/sqlalchemy/ext/declarative/api.py index d0746b2675..09395dc075 100644 --- a/lib/sqlalchemy/ext/declarative/api.py +++ b/lib/sqlalchemy/ext/declarative/api.py @@ -173,12 +173,6 @@ class declared_attr(interfaces._MappedAttribute, property): else: return {"polymorphic_identity":cls.__name__} - .. versionchanged:: 0.8 :class:`.declared_attr` can be used with - non-ORM or extension attributes, such as user-defined attributes - or :func:`.association_proxy` objects, which will be assigned - to the class at class construction time. - - """ def __init__(self, fget, cascading=False): @@ -372,8 +366,6 @@ def as_declarative(**kw): All keyword arguments passed to :func:`.as_declarative` are passed along to :func:`.declarative_base`. - .. versionadded:: 0.8.3 - .. seealso:: :func:`.declarative_base` @@ -659,8 +651,6 @@ class DeferredReflection(object): ReflectedOne.prepare(engine_one) ReflectedTwo.prepare(engine_two) - .. versionadded:: 0.8 - """ @classmethod def prepare(cls, engine): diff --git a/lib/sqlalchemy/ext/instrumentation.py b/lib/sqlalchemy/ext/instrumentation.py index 30a0ab7d73..a72d465fa3 100644 --- a/lib/sqlalchemy/ext/instrumentation.py +++ b/lib/sqlalchemy/ext/instrumentation.py @@ -14,17 +14,6 @@ on the class. For examples of how the instrumentation extension is used, see the example :ref:`examples_instrumentation`. -.. versionchanged:: 0.8 - The :mod:`sqlalchemy.orm.instrumentation` was split out so - that all functionality having to do with non-standard - instrumentation was moved out to :mod:`sqlalchemy.ext.instrumentation`. - When imported, the module installs itself within - :mod:`sqlalchemy.orm.instrumentation` so that it - takes effect, including recognition of - ``__sa_instrumentation_manager__`` on mapped classes, as - well :data:`.instrumentation_finders` - being used to determine class instrumentation resolution. - """ from ..orm import instrumentation as orm_instrumentation from ..orm.instrumentation import ( @@ -207,11 +196,6 @@ class InstrumentationManager(object): The API for this class should be considered as semi-stable, and may change slightly with new releases. - .. versionchanged:: 0.8 - :class:`.InstrumentationManager` was moved from - :mod:`sqlalchemy.orm.instrumentation` to - :mod:`sqlalchemy.ext.instrumentation`. - """ # r4361 added a mandatory (cls) constructor to this interface. diff --git a/lib/sqlalchemy/ext/mutable.py b/lib/sqlalchemy/ext/mutable.py index 11c93b97b6..c98ad2cc42 100644 --- a/lib/sqlalchemy/ext/mutable.py +++ b/lib/sqlalchemy/ext/mutable.py @@ -8,10 +8,6 @@ r"""Provide support for tracking of in-place changes to scalar values, which are propagated into ORM change events on owning parent objects. -.. versionadded:: 0.7 :mod:`sqlalchemy.ext.mutable` replaces SQLAlchemy's - legacy approach to in-place mutations of scalar values; see - :ref:`07_migration_mutation_extension`. - .. _mutable_scalars: Establishing Mutability on Scalar Column Values @@ -214,14 +210,6 @@ be assigned an object value which represents information "composed" from one or more columns from the underlying mapped table. The usual example is that of a geometric "point", and is introduced in :ref:`mapper_composite`. -.. versionchanged:: 0.7 - The internals of :func:`.orm.composite` have been - greatly simplified and in-place mutation detection is no longer enabled by - default; instead, the user-defined value must detect changes on its own and - propagate them to all owning parents. The :mod:`sqlalchemy.ext.mutable` - extension provides the helper class :class:`.MutableComposite`, which is a - slight variant on the :class:`.Mutable` class. - As is the case with :class:`.Mutable`, the user-defined composite class subclasses :class:`.MutableComposite` as a mixin, and detects and delivers change events to its parents via the :meth:`.MutableComposite.changed` method. @@ -319,10 +307,6 @@ make use of the custom composite type:: raise ValueError("tuple or Point expected") return value -.. versionadded:: 0.7.10,0.8.0b2 - Support for the :meth:`.MutableBase.coerce` method in conjunction with - objects of type :class:`.MutableComposite`. - Supporting Pickling -------------------- @@ -666,8 +650,6 @@ class MutableDict(Mutable, dict): coersion to the values placed in the dictionary so that they too are "mutable", and emit events up to their parent structure. - .. versionadded:: 0.8 - .. seealso:: :class:`.MutableList` diff --git a/lib/sqlalchemy/inspection.py b/lib/sqlalchemy/inspection.py index 3a03e25073..190bef0525 100644 --- a/lib/sqlalchemy/inspection.py +++ b/lib/sqlalchemy/inspection.py @@ -26,9 +26,6 @@ is guaranteed to obey a documented API, thus allowing third party tools which build on top of SQLAlchemy configurations to be constructed in a forwards-compatible way. -.. versionadded:: 0.8 The :func:`.inspect` system is introduced - as of version 0.8. - """ from . import util, exc diff --git a/lib/sqlalchemy/orm/attributes.py b/lib/sqlalchemy/orm/attributes.py index cc4913a4a1..61647a7b79 100644 --- a/lib/sqlalchemy/orm/attributes.py +++ b/lib/sqlalchemy/orm/attributes.py @@ -115,8 +115,6 @@ class QueryableAttribute(interfaces._MappedAttribute, :attr:`.QueryableAttribute.property` attribute, as ``MyClass.someattribute.property.info``. - .. versionadded:: 0.8.0 - .. seealso:: :attr:`.SchemaItem.info` diff --git a/lib/sqlalchemy/orm/base.py b/lib/sqlalchemy/orm/base.py index 8c9d562695..a4a4688a27 100644 --- a/lib/sqlalchemy/orm/base.py +++ b/lib/sqlalchemy/orm/base.py @@ -482,8 +482,6 @@ class InspectionAttr(object): """The extension type, if any. Defaults to :data:`.interfaces.NOT_EXTENSION` - .. versionadded:: 0.8.0 - .. seealso:: :data:`.HYBRID_METHOD` @@ -514,9 +512,6 @@ class InspectionAttrInfo(InspectionAttr): :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. - .. versionadded:: 0.8 Added support for .info to all - :class:`.MapperProperty` subclasses. - .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply diff --git a/lib/sqlalchemy/orm/descriptor_props.py b/lib/sqlalchemy/orm/descriptor_props.py index 4d03b56a8a..77e4a4366a 100644 --- a/lib/sqlalchemy/orm/descriptor_props.py +++ b/lib/sqlalchemy/orm/descriptor_props.py @@ -112,10 +112,6 @@ class CompositeProperty(DescriptorProperty): scalar attribute should be loaded when replaced, if not already loaded. See the same flag on :func:`.column_property`. - .. versionchanged:: 0.7 - This flag specifically becomes meaningful - - previously it was a placeholder. - :param group: A group name for this property when marked as deferred. @@ -136,8 +132,6 @@ class CompositeProperty(DescriptorProperty): :param info: Optional data dictionary which will be populated into the :attr:`.MapperProperty.info` attribute of this object. - .. versionadded:: 0.8 - :param extension: an :class:`.AttributeExtension` instance, or list of extensions, which will be prepended to the list of @@ -684,7 +678,7 @@ class ComparableProperty(DescriptorProperty): """Provides a method of applying a :class:`.PropComparator` to any Python descriptor attribute. - .. versionchanged:: 0.7 + .. deprecated:: 0.7 :func:`.comparable_property` is superseded by the :mod:`~sqlalchemy.ext.hybrid` extension. See the example at :ref:`hybrid_custom_comparators`. diff --git a/lib/sqlalchemy/orm/events.py b/lib/sqlalchemy/orm/events.py index 7038e83106..74b075c899 100644 --- a/lib/sqlalchemy/orm/events.py +++ b/lib/sqlalchemy/orm/events.py @@ -40,13 +40,6 @@ class InstrumentationEvents(event.Events): be the subject of these events, when a listener is established on a superclass. - .. versionchanged:: 0.8 - events here will emit based - on comparing the incoming class to the type of class - passed to :func:`.event.listen`. Previously, the - event would fire for any class unconditionally regardless - of what class was sent for listening, despite - documentation which stated the contrary. - """ _target_class_doc = "SomeBaseClass" @@ -143,9 +136,6 @@ class InstanceEvents(event.Events): * the :class:`.Mapper` class itself and the :func:`.mapper` function indicate listening for all mappers. - .. versionchanged:: 0.8.0 instance events can be associated with - unmapped superclasses of mapped classes. - Instance events are closely related to mapper events, but are more specific to the instance and its instrumentation, rather than its system of persistence. @@ -525,9 +515,6 @@ class MapperEvents(event.Events): * the :class:`.Mapper` class itself and the :func:`.mapper` function indicate listening for all mappers. - .. versionchanged:: 0.8.0 mapper events can be associated with - unmapped superclasses of mapped classes. - Mapper events provide hooks into critical sections of the mapper, including those related to object instrumentation, object loading, and object persistence. In particular, the @@ -1371,8 +1358,6 @@ class SessionEvents(event.Events): :class:`.SessionTransaction` for the given :class:`.Session` is available via the :attr:`.Session.transaction` attribute. - .. versionadded:: 0.7.3 - """ def before_flush(self, session, flush_context, instances): @@ -1467,11 +1452,6 @@ class SessionEvents(event.Events): This is called before an add, delete or merge causes the object to be part of the session. - .. versionadded:: 0.8. Note that :meth:`~.SessionEvents.after_attach` - now fires off after the item is part of the session. - :meth:`.before_attach` is provided for those cases where - the item should not yet be part of the session state. - .. seealso:: :meth:`~.SessionEvents.after_attach` diff --git a/lib/sqlalchemy/orm/exc.py b/lib/sqlalchemy/orm/exc.py index dd38bd9c00..89016a06c4 100644 --- a/lib/sqlalchemy/orm/exc.py +++ b/lib/sqlalchemy/orm/exc.py @@ -34,8 +34,6 @@ class StaleDataError(sa_exc.SQLAlchemyError): cannot be made if the new parent was really the most recent "parent". - .. versionadded:: 0.7.4 - """ ConcurrentModificationError = StaleDataError diff --git a/lib/sqlalchemy/orm/interfaces.py b/lib/sqlalchemy/orm/interfaces.py index f837d5b353..7123660351 100644 --- a/lib/sqlalchemy/orm/interfaces.py +++ b/lib/sqlalchemy/orm/interfaces.py @@ -92,9 +92,6 @@ class MapperProperty(_MappedAttribute, InspectionAttr, util.MemoizedSlots): :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. - .. versionadded:: 0.8 Added support for .info to all - :class:`.MapperProperty` subclasses. - .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply diff --git a/lib/sqlalchemy/orm/mapper.py b/lib/sqlalchemy/orm/mapper.py index 46f20b90a2..a80a2f93a0 100644 --- a/lib/sqlalchemy/orm/mapper.py +++ b/lib/sqlalchemy/orm/mapper.py @@ -302,16 +302,6 @@ class Mapper(InspectionAttr): See the change note and example at :ref:`legacy_is_orphan_addition` for more detail on this change. - .. versionadded:: 0.8 - the consideration of a pending object as - an "orphan" has been modified to more closely match the - behavior as that of persistent objects, which is that the object - is expunged from the :class:`.Session` as soon as it is - de-associated from any of its orphan-enabled parents. Previously, - the pending object would be expunged only if de-associated - from all of its orphan-enabled parents. The new flag - ``legacy_is_orphan`` is added to :func:`.orm.mapper` which - re-establishes the legacy behavior. - :param non_primary: Specify that this :class:`.Mapper` is in addition to the "primary" mapper, that is, the one used for persistence. The :class:`.Mapper` created here may be used for ad-hoc @@ -450,11 +440,6 @@ class Mapper(InspectionAttr): "polymorphic_identity":"employee" } - .. versionchanged:: 0.7.4 - ``polymorphic_on`` may be specified as a SQL expression, - or refer to any attribute configured with - :func:`.column_property`, or to the string name of one. - When setting ``polymorphic_on`` to reference an attribute or expression that's not present in the locally mapped :class:`.Table`, yet the value @@ -2215,8 +2200,6 @@ class Mapper(InspectionAttr): ``getattr(mapper.all_orm_descriptors, somename)`` to avoid name collisions. - .. versionadded:: 0.8.0 - .. seealso:: :attr:`.Mapper.attrs` @@ -2947,7 +2930,6 @@ def validates(*names, **kw): sent as well - the validation function must accept an additional argument "is_remove" which will be a boolean. - .. versionadded:: 0.7.7 :param include_backrefs: defaults to ``True``; if ``False``, the validation function will not emit if the originator is an attribute event related via a backref. This can be used for bi-directional diff --git a/lib/sqlalchemy/orm/properties.py b/lib/sqlalchemy/orm/properties.py index 2880913a0e..8820f6a8e8 100644 --- a/lib/sqlalchemy/orm/properties.py +++ b/lib/sqlalchemy/orm/properties.py @@ -67,8 +67,6 @@ class ColumnProperty(StrategizedProperty): which also need to know the "previous" value of the attribute. - .. versionadded:: 0.6.6 - :param comparator_factory: a class which extends :class:`.ColumnProperty.Comparator` which provides custom SQL clause generation for comparison operations. @@ -100,13 +98,9 @@ class ColumnProperty(StrategizedProperty): settings still expires all attributes after a :meth:`.Session.commit` call, however. - .. versionadded:: 0.7.3 - :param info: Optional data dictionary which will be populated into the :attr:`.MapperProperty.info` attribute of this object. - .. versionadded:: 0.8 - :param extension: an :class:`.AttributeExtension` instance, or list of extensions, which will be prepended to the list of attribute listeners for the diff --git a/lib/sqlalchemy/orm/query.py b/lib/sqlalchemy/orm/query.py index 393c431144..8f3e7b26b8 100644 --- a/lib/sqlalchemy/orm/query.py +++ b/lib/sqlalchemy/orm/query.py @@ -493,9 +493,6 @@ class Query(object): to remove same-named columns where one also refers to the other via foreign key or WHERE clause equivalence. - .. versionchanged:: 0.8 the ``with_labels`` and ``reduce_columns`` - keyword arguments were added. - """ q = self.enable_eagerloads(False) if with_labels: @@ -570,8 +567,6 @@ class Query(object): Analogous to :meth:`sqlalchemy.sql.expression.SelectBase.label`. - .. versionadded:: 0.6.5 - """ return self.enable_eagerloads(False).statement.label(name) @@ -582,8 +577,6 @@ class Query(object): Analogous to :meth:`sqlalchemy.sql.expression.SelectBase.as_scalar`. - .. versionadded:: 0.6.5 - """ return self.enable_eagerloads(False).statement.as_scalar() @@ -719,14 +712,6 @@ class Query(object): See the documentation section :ref:`with_polymorphic` for details on how this method is used. - .. versionchanged:: 0.8 - A new and more flexible function - :func:`.orm.with_polymorphic` supersedes - :meth:`.Query.with_polymorphic`, as it can apply the equivalent - functionality to any set of columns or classes in the - :class:`.Query`, not just the "zero mapper". See that - function for a description of arguments. - """ if not self._primary_entity: @@ -1279,8 +1264,6 @@ class Query(object): q = q.join((subq, subq.c.email < Address.email)).\ limit(1) - .. versionadded:: 0.6.5 - """ self._set_entities(entities) @@ -1356,8 +1339,6 @@ class Query(object): This allows ad-hoc recipes to be created for :class:`.Query` objects. See the example at :ref:`hybrid_transformers`. - .. versionadded:: 0.7.4 - """ return fn(self) @@ -1842,16 +1823,6 @@ class Query(object): q = session.query(User).join(Address, User.id==Address.user_id) - .. versionchanged:: 0.7 - In SQLAlchemy 0.6 and earlier, the two argument form of - :meth:`~.Query.join` requires the usage of a tuple: - ``query(User).join((Address, User.id==Address.user_id))``\ . - This calling form is accepted in 0.7 and further, though - is not necessary unless multiple join conditions are passed to - a single :meth:`~.Query.join` call, which itself is also not - generally necessary as it is now equivalent to multiple - calls (this wasn't always the case). - **Advanced Join Targeting and Adaption** There is a lot of flexibility in what the "target" can be when using @@ -2661,8 +2632,6 @@ class Query(object): SELECT HIGH_PRIORITY SQL_SMALL_RESULT ALL users.name AS users_name FROM users - .. versionadded:: 0.7.7 - .. seealso:: :meth:`.HasPrefixes.prefix_with` @@ -3037,8 +3006,6 @@ class Query(object): session.query(literal(True)).filter(q.exists()).scalar() - .. versionadded:: 0.8.1 - """ # .add_columns() for the case that we are a query().select_from(X), @@ -3058,9 +3025,6 @@ class Query(object): SELECT ) AS anon_1 - .. versionchanged:: 0.7 - The above scheme is newly refined as of 0.7b3. - For fine grained control over specific columns to count, to skip the usage of a subquery or otherwise control of the FROM clause, diff --git a/lib/sqlalchemy/orm/relationships.py b/lib/sqlalchemy/orm/relationships.py index 7ac5c1bc8d..144cbc0eb0 100644 --- a/lib/sqlalchemy/orm/relationships.py +++ b/lib/sqlalchemy/orm/relationships.py @@ -40,8 +40,6 @@ def remote(expr): See the section :ref:`relationship_custom_foreign` for a description of use. - .. versionadded:: 0.8 - .. seealso:: :ref:`relationship_custom_foreign` @@ -60,8 +58,6 @@ def foreign(expr): See the section :ref:`relationship_custom_foreign` for a description of use. - .. versionadded:: 0.8 - .. seealso:: :ref:`relationship_custom_foreign` @@ -368,11 +364,6 @@ class RelationshipProperty(StrategizedProperty): reducing performance of the innermost subquery beyond that of what duplicate innermost rows may be causing. - .. versionadded:: 0.8.3 - - :paramref:`~.relationship.distinct_target_key` allows the - subquery eager loader to apply a DISTINCT modifier to the - innermost SELECT. - .. versionchanged:: 0.9.0 - :paramref:`~.relationship.distinct_target_key` now defaults to ``None``, so that the feature enables itself automatically for @@ -427,12 +418,6 @@ class RelationshipProperty(StrategizedProperty): :func:`.relationship` to consider just those columns specified here as "foreign". - .. versionchanged:: 0.8 - A multiple-foreign key join ambiguity can be resolved by - setting the :paramref:`~.relationship.foreign_keys` - parameter alone, without the need to explicitly set - :paramref:`~.relationship.primaryjoin` as well. - 2. The :class:`.Table` being mapped does not actually have :class:`.ForeignKey` or :class:`.ForeignKeyConstraint` constructs present, often because the table @@ -467,19 +452,9 @@ class RelationshipProperty(StrategizedProperty): :func:`.foreign` - allows direct annotation of the "foreign" columns within a :paramref:`~.relationship.primaryjoin` condition. - .. versionadded:: 0.8 - The :func:`.foreign` annotation can also be applied - directly to the :paramref:`~.relationship.primaryjoin` - expression, which is an alternate, more specific system of - describing which columns in a particular - :paramref:`~.relationship.primaryjoin` should be considered - "foreign". - :param info: Optional data dictionary which will be populated into the :attr:`.MapperProperty.info` attribute of this object. - .. versionadded:: 0.8 - :param innerjoin=False: when ``True``, joined eager loads will use an inner join to join against related tables instead of an outer join. The purpose @@ -725,12 +700,6 @@ class RelationshipProperty(StrategizedProperty): and may be passed as a Python-evaluable string when using Declarative. - .. versionchanged:: 0.8 - The :func:`.remote` annotation can also be applied - directly to the ``primaryjoin`` expression, which is an - alternate, more specific system of describing which columns in a - particular ``primaryjoin`` should be considered "remote". - .. seealso:: :ref:`self_referential` - in-depth explanation of how diff --git a/lib/sqlalchemy/orm/session.py b/lib/sqlalchemy/orm/session.py index f5975688ce..f515239756 100644 --- a/lib/sqlalchemy/orm/session.py +++ b/lib/sqlalchemy/orm/session.py @@ -1476,8 +1476,6 @@ class Session(_SessionClassMethods): of objects which involve existing database queries, where the uncompleted object should not yet be flushed. - .. versionadded:: 0.7.6 - """ autoflush = self.autoflush self.autoflush = False @@ -2182,8 +2180,6 @@ class Session(_SessionClassMethods): that they are present in an ordinary way before flush() proceeds. This method is not intended for general use. - .. versionadded:: 0.8 - .. seealso:: ``load_on_pending`` at :func:`.relationship` - this flag @@ -2671,15 +2667,6 @@ class Session(_SessionClassMethods): return session.is_modified(someobject) - .. versionchanged:: 0.8 - When using SQLAlchemy 0.7 and earlier, the ``passive`` - flag should **always** be explicitly set to ``True``, - else SQL loads/autoflushes may proceed which can affect - the modified state itself: - ``session.is_modified(someobject, passive=True)``\ . - In 0.8 and above, the behavior is corrected and - this flag is ignored. - A few caveats to this method apply: * Instances present in the :attr:`.Session.dirty` collection may @@ -2714,10 +2701,9 @@ class Session(_SessionClassMethods): instance upon flush. :param passive: - .. versionchanged:: 0.8 - Ignored for backwards compatibility. - When using SQLAlchemy 0.7 and earlier, this flag should always - be set to ``True``. + .. deprecated:: 0.8 + The ``passive`` flag is deprecated and will be removed + in a future release. The flag is no longer used and is ignored. """ state = object_state(instance) diff --git a/lib/sqlalchemy/orm/util.py b/lib/sqlalchemy/orm/util.py index 4f4e258f7a..12174f00ce 100644 --- a/lib/sqlalchemy/orm/util.py +++ b/lib/sqlalchemy/orm/util.py @@ -652,9 +652,6 @@ def aliased(element, alias=None, name=None, flat=False, adapt_on_names=False): wouldn't have any "column correspondence" to the actual ``UnitPrice.price`` column as it is not a proxy of the original. - .. versionadded:: 0.7.3 - - """ if isinstance(element, expression.FromClause): if adapt_on_names: @@ -1012,8 +1009,6 @@ def was_deleted(object): This is regardless of whether or not the object is persistent or detached. - .. versionadded:: 0.8.0 - .. seealso:: :attr:`.InstanceState.was_deleted` @@ -1050,9 +1045,6 @@ def randomize_unitofwork(): This utility is also available when running the test suite via the ``--reversetop`` flag. - .. versionadded:: 0.8.1 created a standalone version of the - ``--reversetop`` feature. - """ from sqlalchemy.orm import unitofwork, session, mapper, dependency from sqlalchemy.util import topological diff --git a/lib/sqlalchemy/pool.py b/lib/sqlalchemy/pool.py index 4a4b11a51b..af7db9b317 100644 --- a/lib/sqlalchemy/pool.py +++ b/lib/sqlalchemy/pool.py @@ -1223,10 +1223,6 @@ class NullPool(Pool): invalidation are not supported by this Pool implementation, since no connections are held persistently. - .. versionchanged:: 0.7 - :class:`.NullPool` is used by the SQlite dialect automatically - when a file-based database is used. See :ref:`sqlite_toplevel`. - """ def status(self): @@ -1311,11 +1307,6 @@ class AssertionPool(Pool): at a time. Useful for debugging code that is using more connections than desired. - .. versionchanged:: 0.7 - :class:`.AssertionPool` also logs a traceback of where - the original connection was checked out, and reports - this in the assertion error raised. - """ def __init__(self, *args, **kw): diff --git a/lib/sqlalchemy/sql/ddl.py b/lib/sqlalchemy/sql/ddl.py index 224e601aac..e028d198de 100644 --- a/lib/sqlalchemy/sql/ddl.py +++ b/lib/sqlalchemy/sql/ddl.py @@ -433,8 +433,6 @@ class _CreateDropBase(DDLElement): class CreateSchema(_CreateDropBase): """Represent a CREATE SCHEMA statement. - .. versionadded:: 0.7.4 - The argument here is the string name of the schema. """ @@ -453,8 +451,6 @@ class DropSchema(_CreateDropBase): The argument here is the string name of the schema. - .. versionadded:: 0.7.4 - """ __visit_name__ = "drop_schema" @@ -603,13 +599,6 @@ class CreateColumn(_DDLCompiles): which only includes the ``id`` column in the string; the ``xmin`` column will be omitted, but only against the PostgreSQL backend. - .. versionadded:: 0.8.3 The :class:`.CreateColumn` construct supports - skipping of columns by returning ``None`` from a custom compilation - rule. - - .. versionadded:: 0.8 The :class:`.CreateColumn` construct was added - to support custom column creation styles. - """ __visit_name__ = 'create_column' diff --git a/lib/sqlalchemy/sql/dml.py b/lib/sqlalchemy/sql/dml.py index 3d095f95de..a62577ece7 100644 --- a/lib/sqlalchemy/sql/dml.py +++ b/lib/sqlalchemy/sql/dml.py @@ -168,8 +168,6 @@ class UpdateBase( mytable.insert().with_hint("WITH (PAGLOCK)", dialect_name="mssql") - .. versionadded:: 0.7.6 - :param text: Text of the hint. :param selectable: optional :class:`.Table` that specifies an element of the FROM clause within an UPDATE or DELETE @@ -573,8 +571,6 @@ class Insert(ValuesBase): deals with an arbitrary number of rows, so the :attr:`.ResultProxy.inserted_primary_key` accessor does not apply. - .. versionadded:: 0.8.3 - """ if self.parameters: raise exc.InvalidRequestError( @@ -655,9 +651,6 @@ class Update(ValuesBase): as_scalar() ) - .. versionchanged:: 0.7.4 - The WHERE clause can refer to multiple tables. - :param values: Optional dictionary which specifies the ``SET`` conditions of the ``UPDATE``. If left as ``None``, the ``SET`` diff --git a/lib/sqlalchemy/sql/elements.py b/lib/sqlalchemy/sql/elements.py index fb158879bb..f507833262 100644 --- a/lib/sqlalchemy/sql/elements.py +++ b/lib/sqlalchemy/sql/elements.py @@ -1030,11 +1030,6 @@ class BindParameter(ColumnElement): parameters are present, then :paramref:`.bindparam.required` defaults to ``False``. - .. versionchanged:: 0.8 If the ``required`` flag is not specified, - it will be set automatically to ``True`` or ``False`` depending - on whether or not the ``value`` or ``callable`` parameters - were specified. - :param quote: True if this parameter name requires quoting and is not currently known as a SQLAlchemy reserved word; this currently diff --git a/lib/sqlalchemy/sql/functions.py b/lib/sqlalchemy/sql/functions.py index d08b571347..480fbc6550 100644 --- a/lib/sqlalchemy/sql/functions.py +++ b/lib/sqlalchemy/sql/functions.py @@ -111,8 +111,6 @@ class FunctionElement(Executable, ColumnElement, FromClause): See :func:`~.expression.over` for a full description. - .. versionadded:: 0.7 - """ return Over( self, @@ -378,10 +376,6 @@ func = _FunctionGenerator() but are not exactly the same as "functions" from a SQLAlchemy perspective. - .. versionadded:: 0.8 :data:`.func` can return non-function expression - constructs for common quasi-functional names like :func:`.cast` - and :func:`.extract`. - Functions which are interpreted as "generic" functions know how to calculate their return type automatically. For a listing of known generic functions, see :ref:`generic_functions`. @@ -515,15 +509,6 @@ class GenericFunction(util.with_metaclass(_GenericMeta, Function)): >>> print func.geo.buffer() ST_Buffer() - .. versionadded:: 0.8 :class:`.GenericFunction` now supports - automatic registration of new functions as well as package - and custom naming support. - - .. versionchanged:: 0.8 The attribute name ``type`` is used - to specify the function's return type at the class level. - Previously, the name ``__return_type__`` was used. This - name is still recognized for backwards-compatibility. - """ coerce_arguments = True diff --git a/lib/sqlalchemy/sql/operators.py b/lib/sqlalchemy/sql/operators.py index 31d784316c..6e63eb285b 100644 --- a/lib/sqlalchemy/sql/operators.py +++ b/lib/sqlalchemy/sql/operators.py @@ -134,8 +134,6 @@ class Operators(object): A value of 100 will be higher or equal to all operators, and -100 will be lower than or equal to all operators. - .. versionadded:: 0.8 - added the 'precedence' argument. - :param is_comparison: if True, the operator will be considered as a "comparison" operator, that is which evaluates to a boolean true/false value, like ``==``, ``>``, etc. This flag should be set @@ -482,8 +480,6 @@ class ColumnOperators(Operators): This is equivalent to using negation with :meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``. - .. versionadded:: 0.8 - .. seealso:: :meth:`.ColumnOperators.like` @@ -497,8 +493,6 @@ class ColumnOperators(Operators): This is equivalent to using negation with :meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``. - .. versionadded:: 0.8 - .. seealso:: :meth:`.ColumnOperators.ilike` @@ -514,8 +508,6 @@ class ColumnOperators(Operators): usage of ``IS`` may be desirable if comparing to boolean values on certain platforms. - .. versionadded:: 0.7.9 - .. seealso:: :meth:`.ColumnOperators.isnot` """ @@ -529,8 +521,6 @@ class ColumnOperators(Operators): usage of ``IS NOT`` may be desirable if comparing to boolean values on certain platforms. - .. versionadded:: 0.7.9 - .. seealso:: :meth:`.ColumnOperators.is_` """ diff --git a/lib/sqlalchemy/sql/schema.py b/lib/sqlalchemy/sql/schema.py index e47529ee1d..a2638d995e 100644 --- a/lib/sqlalchemy/sql/schema.py +++ b/lib/sqlalchemy/sql/schema.py @@ -205,8 +205,6 @@ class Table(DialectKWArgs, SchemaItem, TableClause): replace existing columns of the same name when :paramref:`.Table.extend_existing` is ``True``. - .. versionadded:: 0.7.5 - .. seealso:: :paramref:`.Table.autoload` @@ -250,10 +248,6 @@ class Table(DialectKWArgs, SchemaItem, TableClause): :class:`.Table`, potentially overwriting existing columns and options of the same name. - .. versionchanged:: 0.7.4 :paramref:`.Table.extend_existing` will - invoke a new reflection operation when combined with - :paramref:`.Table.autoload` set to True. - As is always the case with :paramref:`.Table.autoload`, :class:`.Column` objects can be specified in the same :class:`.Table` constructor, which will take precedence. Below, the existing @@ -1166,9 +1160,6 @@ class Column(SchemaItem, ColumnClause): conditionally rendered differently on different backends, consider custom compilation rules for :class:`.CreateColumn`. - .. versionadded:: 0.8.3 Added the ``system=True`` parameter to - :class:`.Column`. - """ name = kwargs.pop('name', None) @@ -1539,11 +1530,6 @@ class ForeignKey(DialectKWArgs, SchemaItem): (defaults to the column name itself), unless ``link_to_name`` is ``True`` in which case the rendered name of the column is used. - .. versionadded:: 0.7.4 - Note that if the schema name is not included, and the - underlying :class:`.MetaData` has a "schema", that value will - be used. - :param name: Optional string. An in-database name for the key if `constraint` is not provided. @@ -3310,8 +3296,6 @@ class Index(DialectKWArgs, ColumnCollectionMixin, SchemaItem): Index("some_index", func.lower(sometable.c.name)) - .. versionadded:: 0.8 support for functional and expression-based indexes. - An :class:`.Index` can also be manually associated with a :class:`.Table`, either through inline declaration or using :meth:`.Table.append_constraint`. When this approach is used, the names diff --git a/lib/sqlalchemy/sql/selectable.py b/lib/sqlalchemy/sql/selectable.py index eaef8c772d..1e161b9f57 100644 --- a/lib/sqlalchemy/sql/selectable.py +++ b/lib/sqlalchemy/sql/selectable.py @@ -1365,8 +1365,6 @@ class CTE(Generative, HasSuffixes, Alias): :meth:`.SelectBase.cte` method from any selectable. See that method for complete examples. - .. versionadded:: 0.7.6 - """ __visit_name__ = 'cte' @@ -3065,8 +3063,6 @@ class Select(HasPrefixes, HasSuffixes, GenerativeSelect): to those which have the same name as the equivalent. Otherwise, all columns that are equivalent to another are removed. - .. versionadded:: 0.8 - """ return self.with_only_columns( sqlutil.reduce_columns( @@ -3258,21 +3254,6 @@ class Select(HasPrefixes, HasSuffixes, GenerativeSelect): constructs, or other compatible constructs (i.e. ORM-mapped classes) to become part of the correlate collection. - .. versionchanged:: 0.8.0 ORM-mapped classes are accepted by - :meth:`.Select.correlate`. - - .. versionchanged:: 0.8.0 The :meth:`.Select.correlate` method no - longer unconditionally removes entries from the FROM clause; - instead, the candidate FROM entries must also be matched by a FROM - entry located in an enclosing :class:`.Select`, which ultimately - encloses this one as present in the WHERE clause, ORDER BY clause, - HAVING clause, or columns clause of an enclosing :meth:`.Select`. - - .. versionchanged:: 0.8.2 explicit correlation takes place - via any level of nesting of :class:`.Select` objects; in previous - 0.8 versions, correlation would only occur relative to the - immediate enclosing :class:`.Select` construct. - .. seealso:: :meth:`.Select.correlate_except` @@ -3299,17 +3280,9 @@ class Select(HasPrefixes, HasSuffixes, GenerativeSelect): all other FROM elements remain subject to normal auto-correlation behaviors. - .. versionchanged:: 0.8.2 The :meth:`.Select.correlate_except` - method was improved to fully prevent FROM clauses specified here - from being omitted from the immediate FROM clause of this - :class:`.Select`. - If ``None`` is passed, the :class:`.Select` object will correlate all of its FROM entries. - .. versionchanged:: 0.8.2 calling ``correlate_except(None)`` will - correctly auto-correlate all FROM clauses. - :param \*fromclauses: a list of one or more :class:`.FromClause` constructs, or other compatible constructs (i.e. ORM-mapped classes) to become part of the correlate-exception collection. diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py index 643c98eca0..b2b97d690a 100644 --- a/lib/sqlalchemy/sql/sqltypes.py +++ b/lib/sqlalchemy/sql/sqltypes.py @@ -148,9 +148,6 @@ class String(Concatenable, TypeEngine): >>> print select([cast('some string', String(collation='utf8'))]) SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1 - .. versionadded:: 0.8 Added support for COLLATE to all - string types. - :param convert_unicode: When set to ``True``, the :class:`.String` type will assume that input is to be passed as Python Unicode objects under Python 2, diff --git a/lib/sqlalchemy/sql/type_api.py b/lib/sqlalchemy/sql/type_api.py index 69079367b6..e6fba2b152 100644 --- a/lib/sqlalchemy/sql/type_api.py +++ b/lib/sqlalchemy/sql/type_api.py @@ -126,9 +126,6 @@ class TypeEngine(Visitable): 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. - """ should_evaluate_none = False @@ -411,8 +408,6 @@ class TypeEngine(Visitable): :param dialect_name: base name of the dialect which uses this type. (i.e. ``'postgresql'``, ``'mysql'``, etc.) - .. versionadded:: 0.7.2 - """ return Variant(self, {dialect_name: to_instance(type_)}) @@ -647,11 +642,6 @@ class UserDefinedType(util.with_metaclass(VisitableCheckKWArg, TypeEngine)): 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`. - """ return self @@ -800,10 +790,6 @@ class TypeDecorator(SchemaEventTarget, TypeEngine): 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. - """ class Comparator(TypeEngine.Comparator): @@ -1196,8 +1182,6 @@ class Variant(TypeDecorator): 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. """ diff --git a/lib/sqlalchemy/util/_collections.py b/lib/sqlalchemy/util/_collections.py index c801585f00..22112e87b6 100644 --- a/lib/sqlalchemy/util/_collections.py +++ b/lib/sqlalchemy/util/_collections.py @@ -60,11 +60,6 @@ class KeyedTuple(AbstractKeyedTuple): and performance overhead, which is not necessary for the :class:`.Query` object's use case. - .. versionchanged:: 0.8 - Compatibility methods with ``collections.namedtuple()`` have been - added including :attr:`.KeyedTuple._fields` and - :meth:`.KeyedTuple._asdict`. - .. seealso:: :ref:`ormtutorial_querying` @@ -86,8 +81,6 @@ class KeyedTuple(AbstractKeyedTuple): This method provides compatibility with ``collections.namedtuple()``. - .. versionadded:: 0.8 - .. seealso:: :meth:`.KeyedTuple.keys` @@ -104,8 +97,6 @@ class KeyedTuple(AbstractKeyedTuple): This method provides compatibility with ``collections.namedtuple()``, with the exception that the dictionary returned is **not** ordered. - .. versionadded:: 0.8 - """ return dict((key, self.__dict__[key]) for key in self.keys())