--- /srv/reproducible-results/rbuild-debian/r-b-build.9JEM4O51/b1/sqlalchemy_1.4.50+ds1-1_amd64.changes
+++ /srv/reproducible-results/rbuild-debian/r-b-build.9JEM4O51/b2/sqlalchemy_1.4.50+ds1-1_amd64.changes
├── Files
│ @@ -1,5 +1,5 @@
│
│ - 3f67245a2ffb1f76d0a6e36142d10a7b 3720016 doc optional python-sqlalchemy-doc_1.4.50+ds1-1_all.deb
│ + 739570e234d53bb198d30e333edf17f5 3720044 doc optional python-sqlalchemy-doc_1.4.50+ds1-1_all.deb
│ 5644a5f4007e027d67a7e9c2152c87e8 70312 debug optional python3-sqlalchemy-ext-dbgsym_1.4.50+ds1-1_amd64.deb
│ 43fb1fe4a0a459ee6c85e9a9d5ed8dcc 20916 python optional python3-sqlalchemy-ext_1.4.50+ds1-1_amd64.deb
│ 7b9b7746123a45060be2c12bd6e80ed4 1009400 python optional python3-sqlalchemy_1.4.50+ds1-1_all.deb
├── python-sqlalchemy-doc_1.4.50+ds1-1_all.deb
│ ├── file list
│ │ @@ -1,3 +1,3 @@
│ │ -rw-r--r-- 0 0 0 4 2024-01-05 13:47:47.000000 debian-binary
│ │ --rw-r--r-- 0 0 0 13376 2024-01-05 13:47:47.000000 control.tar.xz
│ │ --rw-r--r-- 0 0 0 3706448 2024-01-05 13:47:47.000000 data.tar.xz
│ │ +-rw-r--r-- 0 0 0 13368 2024-01-05 13:47:47.000000 control.tar.xz
│ │ +-rw-r--r-- 0 0 0 3706484 2024-01-05 13:47:47.000000 data.tar.xz
│ ├── control.tar.xz
│ │ ├── control.tar
│ │ │ ├── ./md5sums
│ │ │ │ ├── ./md5sums
│ │ │ │ │┄ Files differ
│ ├── data.tar.xz
│ │ ├── data.tar
│ │ │ ├── ./usr/share/doc/python-sqlalchemy-doc/html/changelog/changelog_10.html
│ │ │ │ @@ -590,15 +590,15 @@
│ │ │ │ Fixed performance regression caused by the fix for #3937 where
│ │ │ │ + Fixed performance regression caused by the fix for #3937 where
│ │ │ │ cx_Oracle as of version 5.3 dropped the Fixed performance regression caused by the fix for #3937 where
│ │ │ │ + Fixed performance regression caused by the fix for #3937 where
│ │ │ │ cx_Oracle as of version 5.3 dropped the Fixed performance regression caused by the fix for #3937 where
│ │ │ │ + Fixed performance regression caused by the fix for #3937 where
│ │ │ │ cx_Oracle as of version 5.3 dropped the Some modifications to how the cx_oracle dialect sets up per-column
│ │ │ │ -outputtype handlers for LOB and numeric datatypes to adjust for potential
│ │ │ │ -changes coming in cx_Oracle 8. References: #52461.0 Changelog¶
│ │ │ │ 1.0.19¶
│ │ │ │ Released: August 3, 2017oracle¶
│ │ │ │
│ │ │ │ -
.UNICODE
symbol from its
│ │ │ │ namespace, which was interpreted as cx_Oracle’s “WITH_UNICODE” mode being
│ │ │ │ turned on unconditionally, which invokes functions on the SQLAlchemy
│ │ │ │ side which convert all strings to unicode unconditionally and causing
│ │ │ │ a performance impact. In fact, per cx_Oracle’s author the
│ │ │ │ “WITH_UNICODE” mode has been removed entirely as of 5.1, so the expensive unicode
│ │ │ │ conversion functions are no longer necessary and are disabled if
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -316,15 +316,15 @@
│ │ │ │ │ # _o_r_a_c_l_e
│ │ │ │ │ # _t_e_s_t_s
│ │ │ │ │ # _m_i_s_c
│ │ │ │ │ ************ 11..00 CChhaannggeelloogg_?¶ ************
│ │ │ │ │ ********** 11..00..1199_?¶ **********
│ │ │ │ │ Released: August 3, 2017
│ │ │ │ │ ******** oorraaccllee_?¶ ********
│ │ │ │ │ - * [[oorraaccllee]] [[bbuugg]] [[ppeerrffoorrmmaannccee]] [[ppyy22kk]] _¶
│ │ │ │ │ + * [[oorraaccllee]] [[ppeerrffoorrmmaannccee]] [[bbuugg]] [[ppyy22kk]] _¶
│ │ │ │ │ Fixed performance regression caused by the fix for _#_3_9_3_7 where cx_Oracle
│ │ │ │ │ as of version 5.3 dropped the .UNICODE symbol from its namespace, which
│ │ │ │ │ was interpreted as cx_Oracle’s “WITH_UNICODE” mode being turned on
│ │ │ │ │ unconditionally, which invokes functions on the SQLAlchemy side which
│ │ │ │ │ convert all strings to unicode unconditionally and causing a performance
│ │ │ │ │ impact. In fact, per cx_Oracle’s author the “WITH_UNICODE” mode has been
│ │ │ │ │ removed entirely as of 5.1, so the expensive unicode conversion functions
│ │ │ ├── ./usr/share/doc/python-sqlalchemy-doc/html/changelog/changelog_11.html
│ │ │ │ @@ -875,15 +875,15 @@
│ │ │ │ 1.1.13¶
│ │ │ │ Released: August 3, 2017oracle¶
│ │ │ │
│ │ │ │ -
│ │ │ │ .UNICODE
symbol from its
│ │ │ │ namespace, which was interpreted as cx_Oracle’s “WITH_UNICODE” mode being
│ │ │ │ turned on unconditionally, which invokes functions on the SQLAlchemy
│ │ │ │ side which convert all strings to unicode unconditionally and causing
│ │ │ │ a performance impact. In fact, per cx_Oracle’s author the
│ │ │ │ “WITH_UNICODE” mode has been removed entirely as of 5.1, so the expensive unicode
│ │ │ │ conversion functions are no longer necessary and are disabled if
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -495,15 +495,15 @@
│ │ │ │ │ the same PRECEDING or FOLLOWING keywords in a range by allowing for the
│ │ │ │ │ left side of the range to be positive and for the right to be negative,
│ │ │ │ │ e.g. (1, 3) is “1 FOLLOWING AND 3 FOLLOWING”.
│ │ │ │ │ References: _#_4_0_5_3
│ │ │ │ │ ********** 11..11..1133_?¶ **********
│ │ │ │ │ Released: August 3, 2017
│ │ │ │ │ ******** oorraaccllee_?¶ ********
│ │ │ │ │ - * [[oorraaccllee]] [[bbuugg]] [[ppeerrffoorrmmaannccee]] [[ppyy22kk]] _¶
│ │ │ │ │ + * [[oorraaccllee]] [[ppeerrffoorrmmaannccee]] [[bbuugg]] [[ppyy22kk]] _¶
│ │ │ │ │ Fixed performance regression caused by the fix for _#_3_9_3_7 where cx_Oracle
│ │ │ │ │ as of version 5.3 dropped the .UNICODE symbol from its namespace, which
│ │ │ │ │ was interpreted as cx_Oracle’s “WITH_UNICODE” mode being turned on
│ │ │ │ │ unconditionally, which invokes functions on the SQLAlchemy side which
│ │ │ │ │ convert all strings to unicode unconditionally and causing a performance
│ │ │ │ │ impact. In fact, per cx_Oracle’s author the “WITH_UNICODE” mode has been
│ │ │ │ │ removed entirely as of 5.1, so the expensive unicode conversion functions
│ │ │ ├── ./usr/share/doc/python-sqlalchemy-doc/html/changelog/changelog_12.html
│ │ │ │ @@ -2979,15 +2979,15 @@
│ │ │ │ oracle¶
│ │ │ │
│ │ │ │ -
│ │ │ │ .UNICODE
symbol from its
│ │ │ │ namespace, which was interpreted as cx_Oracle’s “WITH_UNICODE” mode being
│ │ │ │ turned on unconditionally, which invokes functions on the SQLAlchemy
│ │ │ │ side which convert all strings to unicode unconditionally and causing
│ │ │ │ a performance impact. In fact, per cx_Oracle’s author the
│ │ │ │ “WITH_UNICODE” mode has been removed entirely as of 5.1, so the expensive unicode
│ │ │ │ conversion functions are no longer necessary and are disabled if
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1878,15 +1878,15 @@
│ │ │ │ │ verify the number of rows affected on a target version.
│ │ │ │ │ [[mmssssqqll]] [[bbuugg]] _¶
│ │ │ │ │ Added a rule to SQL Server index reflection to ignore the so-called “heap”
│ │ │ │ │ index that is implicitly present on a table that does not specify a clustered
│ │ │ │ │ index.
│ │ │ │ │ References: _#_4_0_5_9
│ │ │ │ │ ******** oorraaccllee_?¶ ********
│ │ │ │ │ - * [[oorraaccllee]] [[bbuugg]] [[ppeerrffoorrmmaannccee]] [[ppyy22kk]] _¶
│ │ │ │ │ + * [[oorraaccllee]] [[ppeerrffoorrmmaannccee]] [[bbuugg]] [[ppyy22kk]] _¶
│ │ │ │ │ Fixed performance regression caused by the fix for _#_3_9_3_7 where cx_Oracle
│ │ │ │ │ as of version 5.3 dropped the .UNICODE symbol from its namespace, which
│ │ │ │ │ was interpreted as cx_Oracle’s “WITH_UNICODE” mode being turned on
│ │ │ │ │ unconditionally, which invokes functions on the SQLAlchemy side which
│ │ │ │ │ convert all strings to unicode unconditionally and causing a performance
│ │ │ │ │ impact. In fact, per cx_Oracle’s author the “WITH_UNICODE” mode has been
│ │ │ │ │ removed entirely as of 5.1, so the expensive unicode conversion functions
│ │ │ ├── ./usr/share/doc/python-sqlalchemy-doc/html/changelog/changelog_13.html
│ │ │ │ @@ -1803,30 +1803,30 @@
│ │ │ │ oracle¶
│ │ │ │
│ │ │ │ -
Changed the implementation of fetching CLOB and BLOB objects to use │ │ │ │ +
Changed the implementation of fetching CLOB and BLOB objects to use │ │ │ │ cx_Oracle’s native implementation which fetches CLOB/BLOB objects inline │ │ │ │ with other result columns, rather than performing a separate fetch. As │ │ │ │ always, this can be disabled by setting auto_convert_lobs to False.
│ │ │ │As part of this change, the behavior of a CLOB that was given a blank │ │ │ │ string on INSERT now returns None on SELECT, which is now consistent with │ │ │ │ that of VARCHAR on Oracle.
│ │ │ │References: #5314
│ │ │ │ │ │ │ │Some modifications to how the cx_oracle dialect sets up per-column │ │ │ │ +outputtype handlers for LOB and numeric datatypes to adjust for potential │ │ │ │ +changes coming in cx_Oracle 8.
│ │ │ │ +References: #5246
│ │ │ │ + │ │ │ │ +Adjusted dialect loading for firebird://
URIs so the external
│ │ │ │ sqlalchemy-firebird dialect will be used if it has been installed,
│ │ │ │ @@ -2204,15 +2204,15 @@
│ │ │ │
Added keyword arguments to the MutableList.sort()
function so that a
│ │ │ │ key function as well as the “reverse” keyword argument can be provided.
References: #5114
│ │ │ │ │ │ │ │Revised an internal change to the test system added as a result of │ │ │ │ +
Revised an internal change to the test system added as a result of │ │ │ │ #5085 where a testing-related module per dialect would be loaded │ │ │ │ unconditionally upon making use of that dialect, pulling in SQLAlchemy’s │ │ │ │ testing framework as well as the ORM into the module import space. This │ │ │ │ would only impact initial startup time and memory to a modest extent, │ │ │ │ however it’s best that these additional modules aren’t reverse-dependent on │ │ │ │ straight Core usage.
│ │ │ │References: #5180
│ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1144,28 +1144,28 @@ │ │ │ │ │ References: _#_5_2_5_5 │ │ │ │ │ [[mmssssqqll]] [[bbuugg]] [[rreefflleeccttiioonn]] _¶ │ │ │ │ │ Fix a regression introduced by the reflection of computed column in MSSQL when │ │ │ │ │ using SQL server versions before 2012, which does not support the concat │ │ │ │ │ function. │ │ │ │ │ References: _#_5_2_7_1 │ │ │ │ │ ******** oorraaccllee_?¶ ******** │ │ │ │ │ - * [[oorraaccllee]] [[bbuugg]] _¶ │ │ │ │ │ - Some modifications to how the cx_oracle dialect sets up per-column │ │ │ │ │ - outputtype handlers for LOB and numeric datatypes to adjust for potential │ │ │ │ │ - changes coming in cx_Oracle 8. │ │ │ │ │ - References: _#_5_2_4_6 │ │ │ │ │ -[[oorraaccllee]] [[bbuugg]] [[ppeerrffoorrmmaannccee]] _¶ │ │ │ │ │ -Changed the implementation of fetching CLOB and BLOB objects to use cx_Oracle’s │ │ │ │ │ -native implementation which fetches CLOB/BLOB objects inline with other result │ │ │ │ │ -columns, rather than performing a separate fetch. As always, this can be │ │ │ │ │ -disabled by setting auto_convert_lobs to False. │ │ │ │ │ -As part of this change, the behavior of a CLOB that was given a blank string on │ │ │ │ │ -INSERT now returns None on SELECT, which is now consistent with that of VARCHAR │ │ │ │ │ -on Oracle. │ │ │ │ │ -References: _#_5_3_1_4 │ │ │ │ │ + * [[oorraaccllee]] [[ppeerrffoorrmmaannccee]] [[bbuugg]] _¶ │ │ │ │ │ + Changed the implementation of fetching CLOB and BLOB objects to use │ │ │ │ │ + cx_Oracle’s native implementation which fetches CLOB/BLOB objects inline │ │ │ │ │ + with other result columns, rather than performing a separate fetch. As │ │ │ │ │ + always, this can be disabled by setting auto_convert_lobs to False. │ │ │ │ │ + As part of this change, the behavior of a CLOB that was given a blank │ │ │ │ │ + string on INSERT now returns None on SELECT, which is now consistent with │ │ │ │ │ + that of VARCHAR on Oracle. │ │ │ │ │ + References: _#_5_3_1_4 │ │ │ │ │ +[[oorraaccllee]] [[bbuugg]] _¶ │ │ │ │ │ +Some modifications to how the cx_oracle dialect sets up per-column outputtype │ │ │ │ │ +handlers for LOB and numeric datatypes to adjust for potential changes coming │ │ │ │ │ +in cx_Oracle 8. │ │ │ │ │ +References: _#_5_2_4_6 │ │ │ │ │ ******** ffiirreebbiirrdd_?¶ ******** │ │ │ │ │ * [[ffiirreebbiirrdd]] [[cchhaannggee]] _¶ │ │ │ │ │ Adjusted dialect loading for firebird:// URIs so the external sqlalchemy- │ │ │ │ │ firebird dialect will be used if it has been installed, otherwise fall │ │ │ │ │ back to the (now deprecated) internal Firebird dialect. │ │ │ │ │ References: _#_5_2_7_8 │ │ │ │ │ ********** 11..33..1166_?¶ ********** │ │ │ │ │ @@ -1409,15 +1409,15 @@ │ │ │ │ │ but owned by someone else. Pull request courtesy Dave Hirschfeld. │ │ │ │ │ References: _#_5_1_4_6 │ │ │ │ │ ******** mmiisscc_?¶ ******** │ │ │ │ │ * [[uusseeccaassee]] [[eexxtt]] _¶ │ │ │ │ │ Added keyword arguments to the _M_u_t_a_b_l_e_L_i_s_t_._s_o_r_t_(_) function so that a key │ │ │ │ │ function as well as the “reverse” keyword argument can be provided. │ │ │ │ │ References: _#_5_1_1_4 │ │ │ │ │ -[[bbuugg]] [[ppeerrffoorrmmaannccee]] _¶ │ │ │ │ │ +[[ppeerrffoorrmmaannccee]] [[bbuugg]] _¶ │ │ │ │ │ Revised an internal change to the test system added as a result of _#_5_0_8_5 where │ │ │ │ │ a testing-related module per dialect would be loaded unconditionally upon │ │ │ │ │ making use of that dialect, pulling in SQLAlchemy’s testing framework as well │ │ │ │ │ as the ORM into the module import space. This would only impact initial startup │ │ │ │ │ time and memory to a modest extent, however it’s best that these additional │ │ │ │ │ modules aren’t reverse-dependent on straight Core usage. │ │ │ │ │ References: _#_5_1_8_0 │ │ │ ├── ./usr/share/doc/python-sqlalchemy-doc/html/changelog/changelog_14.html │ │ │ │ @@ -2857,36 +2857,36 @@ │ │ │ │ attributes and entities that are installed as part of anInsert
,
│ │ │ │ Update
, or Delete
construct. The
│ │ │ │ Select.column_descriptions
accessor is also now implemented for
│ │ │ │ Core-only selectables.
│ │ │ │ References: #7861
│ │ │ │ │ │ │ │Fixed regression in “dynamic” loader strategy where the │ │ │ │ +
Improvements in memory usage by the ORM, removing a significant set of │ │ │ │ +intermediary expression objects that are typically stored when a copy of an │ │ │ │ +expression object is created. These clones have been greatly reduced, │ │ │ │ +reducing the number of total expression objects stored in memory by │ │ │ │ +ORM mappings by about 30%.
│ │ │ │ +References: #7823
│ │ │ │ + │ │ │ │ +Fixed regression in “dynamic” loader strategy where the
│ │ │ │ Query.filter_by()
method would not be given an appropriate
│ │ │ │ entity to filter from, in the case where a “secondary” table were present
│ │ │ │ in the relationship being queried and the mapping were against something
│ │ │ │ complex such as a “with polymorphic”.
References: #7868
│ │ │ │ │ │ │ │Fixed bug where composite()
attributes would not work in
│ │ │ │ +
Fixed bug where composite()
attributes would not work in
│ │ │ │ conjunction with the selectin_polymorphic()
loader strategy for
│ │ │ │ joined table inheritance.
References: #7801
│ │ │ │ │ │ │ │Improvements in memory usage by the ORM, removing a significant set of │ │ │ │ -intermediary expression objects that are typically stored when a copy of an │ │ │ │ -expression object is created. These clones have been greatly reduced, │ │ │ │ -reducing the number of total expression objects stored in memory by │ │ │ │ -ORM mappings by about 30%.
│ │ │ │ -References: #7823
│ │ │ │ - │ │ │ │ -Fixed issue where the selectin_polymorphic()
loader option would
│ │ │ │ not work with joined inheritance mappers that don’t have a fixed
│ │ │ │ “polymorphic_on” column. Additionally added test support for a wider
│ │ │ │ variety of usage patterns with this construct.
References: #7799
│ │ │ │ │ │ │ │Added a CAST(VARCHAR2(128)) to the “table name”, “owner”, and other │ │ │ │ +
Added a CAST(VARCHAR2(128)) to the “table name”, “owner”, and other │ │ │ │ DDL-name parameters as used in reflection queries against Oracle system │ │ │ │ views such as ALL_TABLES, ALL_TAB_CONSTRAINTS, etc to better enable │ │ │ │ indexing to take place against these columns, as they previously would be │ │ │ │ implicitly handled as NVARCHAR2 due to Python’s use of Unicode for strings; │ │ │ │ these columns are documented in all Oracle versions as being VARCHAR2 with │ │ │ │ lengths varying from 30 to 128 characters depending on server version. │ │ │ │ Additionally, test support has been enabled for Unicode-named DDL │ │ │ │ @@ -5334,15 +5334,24 @@ │ │ │ │
Clarified the current purpose of the │ │ │ │ +
Fixed regression involving how the ORM would resolve a given mapped column │ │ │ │ +to a result row, where under cases such as joined eager loading, a slightly │ │ │ │ +more expensive “fallback” could take place to set up this resolution due to │ │ │ │ +some logic that was removed since 1.3. The issue could also cause │ │ │ │ +deprecation warnings involving column resolution to be emitted when using a │ │ │ │ +1.4 style query with joined eager loading.
│ │ │ │ +References: #6596
│ │ │ │ + │ │ │ │ +Clarified the current purpose of the
│ │ │ │ relationship.bake_queries
flag, which in 1.4 is to enable
│ │ │ │ or disable “lambda caching” of statements within the “lazyload” and
│ │ │ │ “selectinload” loader strategies; this is separate from the more
│ │ │ │ foundational SQL query cache that is used for most statements.
│ │ │ │ Additionally, the lazy loader no longer uses its own cache for many-to-one
│ │ │ │ SQL queries, which was an implementation quirk that doesn’t exist for any
│ │ │ │ other loader scenario. Finally, the “lru cache” warning that the lazyloader
│ │ │ │ @@ -5352,38 +5361,29 @@
│ │ │ │ setting bake_queries=False
for such a relationship will remove this
│ │ │ │ cache from being used, there’s no particular performance gain in this case
│ │ │ │ as using no caching vs. using a cache that needs to refresh often likely
│ │ │ │ still wins out on the caching being used side.
Adjusted the means by which classes such as scoped_session
│ │ │ │ +
Adjusted the means by which classes such as scoped_session
│ │ │ │ and AsyncSession
are generated from the base
│ │ │ │ Session
class, such that custom Session
│ │ │ │ subclasses such as that used by Flask-SQLAlchemy don’t need to implement
│ │ │ │ positional arguments when they call into the superclass method, and can
│ │ │ │ continue using the same argument styles as in previous releases.
References: #6285
│ │ │ │ │ │ │ │Fixed issue where query production for joinedload against a complex left │ │ │ │ +
Fixed issue where query production for joinedload against a complex left │ │ │ │ hand side involving joined-table inheritance could fail to produce a │ │ │ │ correct query, due to a clause adaption issue.
│ │ │ │References: #6595
│ │ │ │ │ │ │ │Fixed regression involving how the ORM would resolve a given mapped column │ │ │ │ -to a result row, where under cases such as joined eager loading, a slightly │ │ │ │ -more expensive “fallback” could take place to set up this resolution due to │ │ │ │ -some logic that was removed since 1.3. The issue could also cause │ │ │ │ -deprecation warnings involving column resolution to be emitted when using a │ │ │ │ -1.4 style query with joined eager loading.
│ │ │ │ -References: #6596
│ │ │ │ - │ │ │ │ -Fixed issue in experimental “select ORM objects from INSERT/UPDATE” use │ │ │ │ case where an error was raised if the statement were against a │ │ │ │ single-table-inheritance subclass.
│ │ │ │References: #6591
│ │ │ │ │ │ │ │The warning that’s emitted for relationship()
when multiple
│ │ │ │ @@ -6227,15 +6227,15 @@
│ │ │ │ synonyms can be established linking to these constructs which work
│ │ │ │ fully. This is a behavior that was semi-explicitly disallowed previously,
│ │ │ │ however since it did not fail in every scenario, explicit support
│ │ │ │ for assoc proxy and hybrids has been added.
References: #6267
│ │ │ │ │ │ │ │Fixed a critical performance issue where the traversal of a │ │ │ │ +
Fixed a critical performance issue where the traversal of a
│ │ │ │ select()
construct would traverse a repetitive product of the
│ │ │ │ represented FROM clauses as they were each referred towards by columns in
│ │ │ │ the columns clause; for a series of nested subqueries with lots of columns
│ │ │ │ this could cause a large delay and significant memory growth. This
│ │ │ │ traversal is used by a wide variety of SQL and ORM functions, including by
│ │ │ │ the ORM Session
when it’s configured to have
│ │ │ │ “table-per-bind”, which while this is not a common use case, it seems to be
│ │ │ │ @@ -9028,15 +9028,22 @@
│ │ │ │
See also
│ │ │ │RowProxy is no longer a “proxy”; is now called Row and behaves like an enhanced named tuple
│ │ │ │References: #4710
│ │ │ │ │ │ │ │Disabled the “unicode returns” check that runs on dialect startup when │ │ │ │ +
The pool “pre-ping” feature has been refined to not invoke for a DBAPI │ │ │ │ +connection that was just opened in the same checkout operation. pre ping │ │ │ │ +only applies to a DBAPI connection that’s been checked into the pool │ │ │ │ +and is being checked out again.
│ │ │ │ +References: #4524
│ │ │ │ + │ │ │ │ +Disabled the “unicode returns” check that runs on dialect startup when │ │ │ │ running under Python 3, which for many years has occurred in order to test │ │ │ │ the current DBAPI’s behavior for whether or not it returns Python Unicode │ │ │ │ or Py2K strings for the VARCHAR and NVARCHAR datatypes. The check still │ │ │ │ occurs by default under Python 2, however the mechanism to test the │ │ │ │ behavior will be removed in SQLAlchemy 2.0 when Python 2 support is also │ │ │ │ removed.
│ │ │ │This logic was very effective when it was needed, however now that Python 3
│ │ │ │ @@ -9047,21 +9054,14 @@
│ │ │ │ dialect flags by setting the dialect level flag returns_unicode_strings
│ │ │ │ to one of String.RETURNS_CONDITIONAL
or
│ │ │ │ String.RETURNS_BYTES
, both of which will enable Unicode conversion
│ │ │ │ even under Python 3.
References: #5315
│ │ │ │ │ │ │ │The pool “pre-ping” feature has been refined to not invoke for a DBAPI │ │ │ │ -connection that was just opened in the same checkout operation. pre ping │ │ │ │ -only applies to a DBAPI connection that’s been checked into the pool │ │ │ │ -and is being checked out again.
│ │ │ │ -References: #4524
│ │ │ │ - │ │ │ │ -Revised the Connection.execution_options.schema_translate_map
│ │ │ │ feature such that the processing of the SQL statement to receive a specific
│ │ │ │ schema name occurs within the execution phase of the statement, rather than
│ │ │ │ at the compile phase. This is to support the statement being efficiently
│ │ │ │ cached. Previously, the current schema being rendered into the statement
│ │ │ │ for a particular run would be considered as part of the cache key itself,
│ │ │ │ meaning that for a run against hundreds of schemas, there would be hundreds
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1901,31 +1901,31 @@
│ │ │ │ │ [[oorrmm]] [[uusseeccaassee]] _¶
│ │ │ │ │ Added new attributes _U_p_d_a_t_e_B_a_s_e_._r_e_t_u_r_n_i_n_g___c_o_l_u_m_n___d_e_s_c_r_i_p_t_i_o_n_s and
│ │ │ │ │ _U_p_d_a_t_e_B_a_s_e_._e_n_t_i_t_y___d_e_s_c_r_i_p_t_i_o_n to allow for inspection of ORM attributes and
│ │ │ │ │ entities that are installed as part of an _I_n_s_e_r_t, _U_p_d_a_t_e, or _D_e_l_e_t_e construct.
│ │ │ │ │ The _S_e_l_e_c_t_._c_o_l_u_m_n___d_e_s_c_r_i_p_t_i_o_n_s accessor is also now implemented for Core-only
│ │ │ │ │ selectables.
│ │ │ │ │ References: _#_7_8_6_1
│ │ │ │ │ +[[oorrmm]] [[ppeerrffoorrmmaannccee]] [[bbuugg]] _¶
│ │ │ │ │ +Improvements in memory usage by the ORM, removing a significant set of
│ │ │ │ │ +intermediary expression objects that are typically stored when a copy of an
│ │ │ │ │ +expression object is created. These clones have been greatly reduced, reducing
│ │ │ │ │ +the number of total expression objects stored in memory by ORM mappings by
│ │ │ │ │ +about 30%.
│ │ │ │ │ +References: _#_7_8_2_3
│ │ │ │ │ [[oorrmm]] [[bbuugg]] [[rreeggrreessssiioonn]] _¶
│ │ │ │ │ Fixed regression in “dynamic” loader strategy where the _Q_u_e_r_y_._f_i_l_t_e_r___b_y_(_)
│ │ │ │ │ method would not be given an appropriate entity to filter from, in the case
│ │ │ │ │ where a “secondary” table were present in the relationship being queried and
│ │ │ │ │ the mapping were against something complex such as a “with polymorphic”.
│ │ │ │ │ References: _#_7_8_6_8
│ │ │ │ │ [[oorrmm]] [[bbuugg]] _¶
│ │ │ │ │ Fixed bug where _c_o_m_p_o_s_i_t_e_(_) attributes would not work in conjunction with the
│ │ │ │ │ _s_e_l_e_c_t_i_n___p_o_l_y_m_o_r_p_h_i_c_(_) loader strategy for joined table inheritance.
│ │ │ │ │ References: _#_7_8_0_1
│ │ │ │ │ -[[oorrmm]] [[bbuugg]] [[ppeerrffoorrmmaannccee]] _¶
│ │ │ │ │ -Improvements in memory usage by the ORM, removing a significant set of
│ │ │ │ │ -intermediary expression objects that are typically stored when a copy of an
│ │ │ │ │ -expression object is created. These clones have been greatly reduced, reducing
│ │ │ │ │ -the number of total expression objects stored in memory by ORM mappings by
│ │ │ │ │ -about 30%.
│ │ │ │ │ -References: _#_7_8_2_3
│ │ │ │ │ [[oorrmm]] [[bbuugg]] _¶
│ │ │ │ │ Fixed issue where the _s_e_l_e_c_t_i_n___p_o_l_y_m_o_r_p_h_i_c_(_) loader option would not work with
│ │ │ │ │ joined inheritance mappers that don’t have a fixed “polymorphic_on” column.
│ │ │ │ │ Additionally added test support for a wider variety of usage patterns with this
│ │ │ │ │ construct.
│ │ │ │ │ References: _#_7_7_9_9
│ │ │ │ │ [[oorrmm]] [[bbuugg]] _¶
│ │ │ │ │ @@ -3123,15 +3123,15 @@
│ │ │ │ │ * [[mmssssqqll]] [[bbuugg]] [[rreefflleeccttiioonn]] _¶
│ │ │ │ │ Fixed an issue where sqlalchemy.engine.reflection.has_table() returned
│ │ │ │ │ True for local temporary tables that actually belonged to a different SQL
│ │ │ │ │ Server session (connection). An extra check is now performed to ensure
│ │ │ │ │ that the temp table detected is in fact owned by the current session.
│ │ │ │ │ References: _#_6_9_1_0
│ │ │ │ │ ******** oorraaccllee_?¶ ********
│ │ │ │ │ - * [[oorraaccllee]] [[bbuugg]] [[ppeerrffoorrmmaannccee]] _¶
│ │ │ │ │ + * [[oorraaccllee]] [[ppeerrffoorrmmaannccee]] [[bbuugg]] _¶
│ │ │ │ │ Added a CAST(VARCHAR2(128)) to the “table name”, “owner”, and other DDL-
│ │ │ │ │ name parameters as used in reflection queries against Oracle system views
│ │ │ │ │ such as ALL_TABLES, ALL_TAB_CONSTRAINTS, etc to better enable indexing to
│ │ │ │ │ take place against these columns, as they previously would be implicitly
│ │ │ │ │ handled as NVARCHAR2 due to Python’s use of Unicode for strings; these
│ │ │ │ │ columns are documented in all Oracle versions as being VARCHAR2 with
│ │ │ │ │ lengths varying from 30 to 128 characters depending on server version.
│ │ │ │ │ @@ -3631,51 +3631,50 @@
│ │ │ │ │ the INSERT thus triggering SQLAlchemy’s feature of setting IDENTITY INSERT to
│ │ │ │ │ “on”; it’s in this directive where the schema translate map would fail to be
│ │ │ │ │ honored.
│ │ │ │ │ References: _#_6_6_5_8
│ │ │ │ │ ********** 11..44..1188_?¶ **********
│ │ │ │ │ Released: June 10, 2021
│ │ │ │ │ ******** oorrmm_?¶ ********
│ │ │ │ │ - * [[oorrmm]] [[bbuugg]] _¶
│ │ │ │ │ - Clarified the current purpose of the _r_e_l_a_t_i_o_n_s_h_i_p_._b_a_k_e___q_u_e_r_i_e_s flag,
│ │ │ │ │ - which in 1.4 is to enable or disable “lambda caching” of statements
│ │ │ │ │ - within the “lazyload” and “selectinload” loader strategies; this is
│ │ │ │ │ - separate from the more foundational SQL query cache that is used for most
│ │ │ │ │ - statements. Additionally, the lazy loader no longer uses its own cache
│ │ │ │ │ - for many-to-one SQL queries, which was an implementation quirk that
│ │ │ │ │ - doesn’t exist for any other loader scenario. Finally, the “lru cache”
│ │ │ │ │ - warning that the lazyloader and selectinloader strategies could emit when
│ │ │ │ │ - handling a wide array of class/relationship combinations has been
│ │ │ │ │ - removed; based on analysis of some end-user cases, this warning doesn’t
│ │ │ │ │ - suggest any significant issue. While setting bake_queries=False for such
│ │ │ │ │ - a relationship will remove this cache from being used, there’s no
│ │ │ │ │ - particular performance gain in this case as using no caching vs. using a
│ │ │ │ │ - cache that needs to refresh often likely still wins out on the caching
│ │ │ │ │ - being used side.
│ │ │ │ │ - References: _#_6_0_7_2, _#_6_4_8_7
│ │ │ │ │ + * [[oorrmm]] [[ppeerrffoorrmmaannccee]] [[bbuugg]] [[rreeggrreessssiioonn]] _¶
│ │ │ │ │ + Fixed regression involving how the ORM would resolve a given mapped
│ │ │ │ │ + column to a result row, where under cases such as joined eager loading, a
│ │ │ │ │ + slightly more expensive “fallback” could take place to set up this
│ │ │ │ │ + resolution due to some logic that was removed since 1.3. The issue could
│ │ │ │ │ + also cause deprecation warnings involving column resolution to be emitted
│ │ │ │ │ + when using a 1.4 style query with joined eager loading.
│ │ │ │ │ + References: _#_6_5_9_6
│ │ │ │ │ +[[oorrmm]] [[bbuugg]] _¶
│ │ │ │ │ +Clarified the current purpose of the _r_e_l_a_t_i_o_n_s_h_i_p_._b_a_k_e___q_u_e_r_i_e_s flag, which in
│ │ │ │ │ +1.4 is to enable or disable “lambda caching” of statements within the
│ │ │ │ │ +“lazyload” and “selectinload” loader strategies; this is separate from the more
│ │ │ │ │ +foundational SQL query cache that is used for most statements. Additionally,
│ │ │ │ │ +the lazy loader no longer uses its own cache for many-to-one SQL queries, which
│ │ │ │ │ +was an implementation quirk that doesn’t exist for any other loader scenario.
│ │ │ │ │ +Finally, the “lru cache” warning that the lazyloader and selectinloader
│ │ │ │ │ +strategies could emit when handling a wide array of class/relationship
│ │ │ │ │ +combinations has been removed; based on analysis of some end-user cases, this
│ │ │ │ │ +warning doesn’t suggest any significant issue. While setting bake_queries=False
│ │ │ │ │ +for such a relationship will remove this cache from being used, there’s no
│ │ │ │ │ +particular performance gain in this case as using no caching vs. using a cache
│ │ │ │ │ +that needs to refresh often likely still wins out on the caching being used
│ │ │ │ │ +side.
│ │ │ │ │ +References: _#_6_0_7_2, _#_6_4_8_7
│ │ │ │ │ [[oorrmm]] [[bbuugg]] [[rreeggrreessssiioonn]] _¶
│ │ │ │ │ Adjusted the means by which classes such as _s_c_o_p_e_d___s_e_s_s_i_o_n and _A_s_y_n_c_S_e_s_s_i_o_n are
│ │ │ │ │ generated from the base _S_e_s_s_i_o_n class, such that custom _S_e_s_s_i_o_n subclasses such
│ │ │ │ │ as that used by Flask-SQLAlchemy don’t need to implement positional arguments
│ │ │ │ │ when they call into the superclass method, and can continue using the same
│ │ │ │ │ argument styles as in previous releases.
│ │ │ │ │ References: _#_6_2_8_5
│ │ │ │ │ [[oorrmm]] [[bbuugg]] [[rreeggrreessssiioonn]] _¶
│ │ │ │ │ Fixed issue where query production for joinedload against a complex left hand
│ │ │ │ │ side involving joined-table inheritance could fail to produce a correct query,
│ │ │ │ │ due to a clause adaption issue.
│ │ │ │ │ References: _#_6_5_9_5
│ │ │ │ │ -[[oorrmm]] [[bbuugg]] [[ppeerrffoorrmmaannccee]] [[rreeggrreessssiioonn]] _¶
│ │ │ │ │ -Fixed regression involving how the ORM would resolve a given mapped column to a
│ │ │ │ │ -result row, where under cases such as joined eager loading, a slightly more
│ │ │ │ │ -expensive “fallback” could take place to set up this resolution due to some
│ │ │ │ │ -logic that was removed since 1.3. The issue could also cause deprecation
│ │ │ │ │ -warnings involving column resolution to be emitted when using a 1.4 style query
│ │ │ │ │ -with joined eager loading.
│ │ │ │ │ -References: _#_6_5_9_6
│ │ │ │ │ [[oorrmm]] [[bbuugg]] _¶
│ │ │ │ │ Fixed issue in experimental “select ORM objects from INSERT/UPDATE” use case
│ │ │ │ │ where an error was raised if the statement were against a single-table-
│ │ │ │ │ inheritance subclass.
│ │ │ │ │ References: _#_6_5_9_1
│ │ │ │ │ [[oorrmm]] [[bbuugg]] _¶
│ │ │ │ │ The warning that’s emitted for _r_e_l_a_t_i_o_n_s_h_i_p_(_) when multiple relationships would
│ │ │ │ │ @@ -4245,15 +4244,15 @@
│ │ │ │ │ Established support for synoynm() in conjunction with hybrid property,
│ │ │ │ │ assocaitionproxy is set up completely, including that synonyms can be
│ │ │ │ │ established linking to these constructs which work fully. This is a
│ │ │ │ │ behavior that was semi-explicitly disallowed previously, however since it
│ │ │ │ │ did not fail in every scenario, explicit support for assoc proxy and
│ │ │ │ │ hybrids has been added.
│ │ │ │ │ References: _#_6_2_6_7
│ │ │ │ │ -[[oorrmm]] [[bbuugg]] [[ppeerrffoorrmmaannccee]] [[rreeggrreessssiioonn]] [[ssqqll]] _¶
│ │ │ │ │ +[[oorrmm]] [[ppeerrffoorrmmaannccee]] [[bbuugg]] [[rreeggrreessssiioonn]] [[ssqqll]] _¶
│ │ │ │ │ Fixed a critical performance issue where the traversal of a _s_e_l_e_c_t_(_) construct
│ │ │ │ │ would traverse a repetitive product of the represented FROM clauses as they
│ │ │ │ │ were each referred towards by columns in the columns clause; for a series of
│ │ │ │ │ nested subqueries with lots of columns this could cause a large delay and
│ │ │ │ │ significant memory growth. This traversal is used by a wide variety of SQL and
│ │ │ │ │ ORM functions, including by the ORM _S_e_s_s_i_o_n when it’s configured to have
│ │ │ │ │ “table-per-bind”, which while this is not a common use case, it seems to be
│ │ │ │ │ @@ -6223,15 +6222,21 @@
│ │ │ │ │ returned by the ResultProxy is now the _L_e_g_a_c_y_R_o_w subclass, which maintains
│ │ │ │ │ mapping/tuple hybrid behavior, however the base _R_o_w class now behaves more
│ │ │ │ │ fully like a named tuple.
│ │ │ │ │ See also
│ │ │ │ │ _R_o_w_P_r_o_x_y_ _i_s_ _n_o_ _l_o_n_g_e_r_ _a_ _“_p_r_o_x_y_”_;_ _i_s_ _n_o_w_ _c_a_l_l_e_d_ _R_o_w_ _a_n_d_ _b_e_h_a_v_e_s_ _l_i_k_e_ _a_n_ _e_n_h_a_n_c_e_d
│ │ │ │ │ _n_a_m_e_d_ _t_u_p_l_e
│ │ │ │ │ References: _#_4_7_1_0
│ │ │ │ │ -[[eennggiinnee]] [[cchhaannggee]] [[ppeerrffoorrmmaannccee]] [[ppyy33kk]] _¶
│ │ │ │ │ +[[eennggiinnee]] [[ppeerrffoorrmmaannccee]] _¶
│ │ │ │ │ +The pool “pre-ping” feature has been refined to not invoke for a DBAPI
│ │ │ │ │ +connection that was just opened in the same checkout operation. pre ping only
│ │ │ │ │ +applies to a DBAPI connection that’s been checked into the pool and is being
│ │ │ │ │ +checked out again.
│ │ │ │ │ +References: _#_4_5_2_4
│ │ │ │ │ +[[eennggiinnee]] [[ppeerrffoorrmmaannccee]] [[cchhaannggee]] [[ppyy33kk]] _¶
│ │ │ │ │ Disabled the “unicode returns” check that runs on dialect startup when running
│ │ │ │ │ under Python 3, which for many years has occurred in order to test the current
│ │ │ │ │ DBAPI’s behavior for whether or not it returns Python Unicode or Py2K strings
│ │ │ │ │ for the VARCHAR and NVARCHAR datatypes. The check still occurs by default under
│ │ │ │ │ Python 2, however the mechanism to test the behavior will be removed in
│ │ │ │ │ SQLAlchemy 2.0 when Python 2 support is also removed.
│ │ │ │ │ This logic was very effective when it was needed, however now that Python 3 is
│ │ │ │ │ @@ -6239,20 +6244,14 @@
│ │ │ │ │ datatypes. In the unlikely case that a third party DBAPI does not support this,
│ │ │ │ │ the conversion logic within _S_t_r_i_n_g is still available and the third party
│ │ │ │ │ dialect may specify this in its upfront dialect flags by setting the dialect
│ │ │ │ │ level flag returns_unicode_strings to one of _S_t_r_i_n_g_._R_E_T_U_R_N_S___C_O_N_D_I_T_I_O_N_A_L or
│ │ │ │ │ _S_t_r_i_n_g_._R_E_T_U_R_N_S___B_Y_T_E_S, both of which will enable Unicode conversion even under
│ │ │ │ │ Python 3.
│ │ │ │ │ References: _#_5_3_1_5
│ │ │ │ │ -[[eennggiinnee]] [[ppeerrffoorrmmaannccee]] _¶
│ │ │ │ │ -The pool “pre-ping” feature has been refined to not invoke for a DBAPI
│ │ │ │ │ -connection that was just opened in the same checkout operation. pre ping only
│ │ │ │ │ -applies to a DBAPI connection that’s been checked into the pool and is being
│ │ │ │ │ -checked out again.
│ │ │ │ │ -References: _#_4_5_2_4
│ │ │ │ │ [[eennggiinnee]] [[bbuugg]] _¶
│ │ │ │ │ Revised the _C_o_n_n_e_c_t_i_o_n_._e_x_e_c_u_t_i_o_n___o_p_t_i_o_n_s_._s_c_h_e_m_a___t_r_a_n_s_l_a_t_e___m_a_p feature such that
│ │ │ │ │ the processing of the SQL statement to receive a specific schema name occurs
│ │ │ │ │ within the execution phase of the statement, rather than at the compile phase.
│ │ │ │ │ This is to support the statement being efficiently cached. Previously, the
│ │ │ │ │ current schema being rendered into the statement for a particular run would be
│ │ │ │ │ considered as part of the cache key itself, meaning that for a run against
│ │ │ ├── ./usr/share/doc/python-sqlalchemy-doc/html/orm/examples.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -308,46 +308,46 @@
│ │ │ │
Examples illustrating the usage of the “association object” pattern, │ │ │ │ where an intermediary class mediates the relationship between two │ │ │ │ classes that are associated in a many-to-many pattern.
│ │ │ │Listing of files:
basic_association.py - Illustrate a many-to-many relationship between an │ │ │ │ +“Order” and a collection of “Item” objects, associating a purchase price │ │ │ │ +with each via an association object called “OrderItem”
│ │ │ │ +dict_of_sets_with_default.py - An advanced association proxy example which │ │ │ │ illustrates nesting of association proxies to produce multi-level Python │ │ │ │ collections, in this case a dictionary with string keys and sets of integers │ │ │ │ as values, which conceal the underlying mapped classes.
│ │ │ │proxied_association.py - Same example as basic_association, adding in
│ │ │ │ usage of sqlalchemy.ext.associationproxy
to make explicit references
│ │ │ │ to OrderItem
optional.
basic_association.py - Illustrate a many-to-many relationship between an │ │ │ │ -“Order” and a collection of “Item” objects, associating a purchase price │ │ │ │ -with each via an association object called “OrderItem”
│ │ │ │ -Examples illustrating the asyncio engine feature of SQLAlchemy.
│ │ │ │Listing of files:
gather_orm_statements.py - Illustrates how to run many statements concurrently using asyncio.gather()
│ │ │ │ -along many asyncio database connections, merging ORM results into a single
│ │ │ │ -AsyncSession
.
async_orm.py - Illustrates use of the sqlalchemy.ext.asyncio.AsyncSession object │ │ │ │ for asynchronous ORM use.
│ │ │ │basic.py - Illustrates the asyncio engine / connection interface.
│ │ │ │ +gather_orm_statements.py - Illustrates how to run many statements concurrently using asyncio.gather()
│ │ │ │ +along many asyncio database connections, merging ORM results into a single
│ │ │ │ +AsyncSession
.
greenlet_orm.py - Illustrates use of the sqlalchemy.ext.asyncio.AsyncSession object │ │ │ │ for asynchronous ORM use, including the optional run_sync() method.
│ │ │ │basic.py - Illustrates the asyncio engine / connection interface.
│ │ │ │ +An example of persistence for a directed graph structure. The │ │ │ │ graph is stored as a collection of edges, each referencing both a │ │ │ │ @@ -388,32 +388,32 @@ │ │ │ │ are modernized versions of recipes presented in the 2007 blog post │ │ │ │ Polymorphic Associations with SQLAlchemy.
│ │ │ │Listing of files:
table_per_related.py - Illustrates a generic association which persists association │ │ │ │ objects within individual tables, each one generated to persist │ │ │ │ those objects on behalf of a particular parent class.
│ │ │ │generic_fk.py - Illustrates a so-called “generic foreign key”, in a similar fashion │ │ │ │ -to that of popular frameworks such as Django, ROR, etc. This │ │ │ │ -approach bypasses standard referential integrity │ │ │ │ -practices, in that the “foreign key” column is not actually │ │ │ │ -constrained to refer to any particular table; instead, │ │ │ │ -in-application logic is used to determine which table is referenced.
│ │ │ │ +table_per_association.py - Illustrates a mixin which provides a generic association │ │ │ │ +via a individually generated association tables for each parent class. │ │ │ │ +The associated objects themselves are persisted in a single table │ │ │ │ +shared among all parents.
│ │ │ │discriminator_on_association.py - Illustrates a mixin which provides a generic association │ │ │ │ using a single target table and a single association table, │ │ │ │ referred to by all parent tables. The association table │ │ │ │ contains a “discriminator” column which determines what type of │ │ │ │ parent object associates to each particular row in the association │ │ │ │ table.
│ │ │ │table_per_association.py - Illustrates a mixin which provides a generic association │ │ │ │ -via a individually generated association tables for each parent class. │ │ │ │ -The associated objects themselves are persisted in a single table │ │ │ │ -shared among all parents.
│ │ │ │ +generic_fk.py - Illustrates a so-called “generic foreign key”, in a similar fashion │ │ │ │ +to that of popular frameworks such as Django, ROR, etc. This │ │ │ │ +approach bypasses standard referential integrity │ │ │ │ +practices, in that the “foreign key” column is not actually │ │ │ │ +constrained to refer to any particular table; instead, │ │ │ │ +in-application logic is used to determine which table is referenced.
│ │ │ │Large collection example.
│ │ │ │ @@ -503,30 +503,30 @@ │ │ │ │ │ │ │ │Listing of files:
bulk_updates.py - This series of tests will illustrate different ways to UPDATE a large number │ │ │ │ of rows in bulk (under construction! there’s just one test at the moment)
│ │ │ │large_resultsets.py - In this series of tests, we are looking at time to load a large number │ │ │ │ +of very small and simple rows.
│ │ │ │ +single_inserts.py - In this series of tests, we’re looking at a method that inserts a row │ │ │ │ within a distinct transaction, and afterwards returns to essentially a │ │ │ │ “closed” state. This would be analogous to an API call that starts up │ │ │ │ a database connection, inserts the row, commits and closes.
│ │ │ │bulk_inserts.py - This series of tests illustrates different ways to INSERT a large number │ │ │ │ -of rows in bulk.
│ │ │ │ -large_resultsets.py - In this series of tests, we are looking at time to load a large number │ │ │ │ -of very small and simple rows.
│ │ │ │ -__main__.py - Allows the examples/performance package to be run as a script.
│ │ │ │short_selects.py - This series of tests illustrates different ways to SELECT a single │ │ │ │ record by primary key
│ │ │ │bulk_inserts.py - This series of tests illustrates different ways to INSERT a large number │ │ │ │ +of rows in bulk.
│ │ │ │ +This is the default form of run:
│ │ │ │$ python -m examples.performance single_inserts
│ │ │ │ @@ -668,22 +668,22 @@
│ │ │ │
│ │ │ │
│ │ │ │ Relationship Join Conditions¶
│ │ │ │ Examples of various relationship()
configurations,
│ │ │ │ which make use of the primaryjoin
argument to compose special types
│ │ │ │ of join conditions.
│ │ │ │ Listing of files:
│ │ │ │ -threeway.py - Illustrate a “three way join” - where a primary table joins to a remote
│ │ │ │ -table via an association table, but then the primary table also needs
│ │ │ │ -to refer to some columns in the remote table directly.
│ │ │ │ -
│ │ │ │ cast.py - Illustrate a relationship()
that joins two columns where those
│ │ │ │ columns are not of the same type, and a CAST must be used on the SQL
│ │ │ │ side in order to match them.
│ │ │ │
│ │ │ │ +threeway.py - Illustrate a “three way join” - where a primary table joins to a remote
│ │ │ │ +table via an association table, but then the primary table also needs
│ │ │ │ +to refer to some columns in the remote table directly.
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Space Invaders¶
│ │ │ │ A Space Invaders game using SQLite as the state machine.
│ │ │ │ Originally developed in 2012. Adapted to work in Python 3.
│ │ │ │ @@ -838,23 +838,23 @@
│ │ │ │ concept of a “vertical table” structure, like those illustrated in
│ │ │ │ Vertical Attribute Mapping examples.
│ │ │ │
│ │ │ │ versioned_rows.py - Illustrates a method to intercept changes on objects, turning
│ │ │ │ an UPDATE statement on a single row into an INSERT statement, so that a new
│ │ │ │ row is inserted with the new data, keeping the old row intact.
│ │ │ │
│ │ │ │ -versioned_rows_w_versionid.py - Illustrates a method to intercept changes on objects, turning
│ │ │ │ -an UPDATE statement on a single row into an INSERT statement, so that a new
│ │ │ │ -row is inserted with the new data, keeping the old row intact.
│ │ │ │ -
│ │ │ │ versioned_update_old_row.py - Illustrates the same UPDATE into INSERT technique of versioned_rows.py
,
│ │ │ │ but also emits an UPDATE on the old row to affect a change in timestamp.
│ │ │ │ Also includes a SessionEvents.do_orm_execute()
hook to limit queries
│ │ │ │ to only the most recent version.
│ │ │ │
│ │ │ │ +versioned_rows_w_versionid.py - Illustrates a method to intercept changes on objects, turning
│ │ │ │ +an UPDATE statement on a single row into an INSERT statement, so that a new
│ │ │ │ +row is inserted with the new data, keeping the old row intact.
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Vertical Attribute Mapping¶
│ │ │ │ Illustrates “vertical table” mappings.
│ │ │ │ @@ -879,57 +879,57 @@
│ │ │ │ q = (session.query(Animal).
│ │ │ │ filter(Animal.facts.any(
│ │ │ │ and_(AnimalFact.key == u'weasel-like',
│ │ │ │ AnimalFact.value == True))))
│ │ │ │ print('weasel-like animals', q.all())
Listing of files:
dictlike-polymorphic.py - Mapping a polymorphic-valued vertical table as a dictionary.
│ │ │ │ -dictlike.py - Mapping a vertical table as a dictionary.
│ │ │ │dictlike-polymorphic.py - Mapping a polymorphic-valued vertical table as a dictionary.
│ │ │ │ +Working examples of single-table, joined-table, and concrete-table │ │ │ │ inheritance as described in Mapping Class Inheritance Hierarchies.
│ │ │ │Listing of files:
single.py - Single-table (table-per-hierarchy) inheritance example.
│ │ │ │ -concrete.py - Concrete-table (table-per-class) inheritance example.
│ │ │ │joined.py - Joined-table (table-per-subclass) inheritance example.
│ │ │ │single.py - Single-table (table-per-hierarchy) inheritance example.
│ │ │ │ +Examples illustrating modifications to SQLAlchemy’s attribute management │ │ │ │ system.
│ │ │ │Listing of files:
custom_management.py - Illustrates customized class instrumentation, using
│ │ │ │ +the sqlalchemy.ext.instrumentation
extension package.
active_column_defaults.py - Illustrates use of the AttributeEvents.init_scalar()
│ │ │ │ event, in conjunction with Core column defaults to provide
│ │ │ │ ORM objects that automatically produce the default value
│ │ │ │ when an un-set attribute is accessed.
listen_for_events.py - Illustrates how to attach events to all instrumented attributes │ │ │ │ and listen for change events.
│ │ │ │custom_management.py - Illustrates customized class instrumentation, using
│ │ │ │ -the sqlalchemy.ext.instrumentation
extension package.
A basic example of using the SQLAlchemy Sharding API. │ │ │ │ Sharding refers to horizontally scaling data across multiple │ │ │ │ @@ -958,21 +958,21 @@ │ │ │ │
The construction of generic sharding routines is an ambitious approach │ │ │ │ to the issue of organizing instances among multiple databases. For a │ │ │ │ more plain-spoken alternative, the “distinct entity” approach │ │ │ │ is a simple method of assigning objects to different tables (and potentially │ │ │ │ database nodes) in an explicit way - described on the wiki at │ │ │ │ EntityName.
│ │ │ │Listing of files:
separate_tables.py - Illustrates sharding using a single SQLite database, that will however │ │ │ │ -have multiple tables using a naming convention.
│ │ │ │ +separate_databases.py - Illustrates sharding using distinct SQLite databases.
│ │ │ │separate_schema_translates.py - Illustrates sharding using a single database with multiple schemas, │ │ │ │ where a different “schema_translates_map” can be used for each shard.
│ │ │ │separate_databases.py - Illustrates sharding using distinct SQLite databases.
│ │ │ │ +separate_tables.py - Illustrates sharding using a single SQLite database, that will however │ │ │ │ +have multiple tables using a naming convention.
│ │ │ │