Hello community, here is the log from the commit of package python-SQLAlchemy for openSUSE:Factory checked in at 2018-06-27 10:22:07 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-SQLAlchemy (Old) and /work/SRC/openSUSE:Factory/.python-SQLAlchemy.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-SQLAlchemy" Wed Jun 27 10:22:07 2018 rev:51 rq:619112 version:1.2.8 Changes: -------- --- /work/SRC/openSUSE:Factory/python-SQLAlchemy/python-SQLAlchemy.changes 2018-04-26 13:37:39.592897096 +0200 +++ /work/SRC/openSUSE:Factory/.python-SQLAlchemy.new/python-SQLAlchemy.changes 2018-06-27 10:22:12.222325894 +0200 @@ -1,0 +2,125 @@ +Tue Jun 26 06:55:57 UTC 2018 - mimi...@gmail.com + +- add upstream fix_test_reflection.patch to fix tests with new sqlite + +------------------------------------------------------------------- +Thu Jun 21 23:01:18 UTC 2018 - h...@urpla.net + +- update to version 1.2.8: + * orm + + [orm] [bug] Fixed regression in 1.2.7 caused by #4228, which + itself was fixing a 1.2-level regression, where the query_cls + callable passed to a Session was assumed to be a subclass of + Query with class method availability, as opposed to an + arbitrary callable. In particular, the dogpile caching example + illustrates query_cls as a function and not a Query subclass. + References: #4256 + + [orm] [bug] Fixed a long-standing regression that occurred in + version 1.0, which prevented the use of a custom MapperOption + that alters the _params of a Query object for a lazy load, + since the lazy loader itself would overwrite those parameters. + This applies to the “temporal range” example on the wiki. Note + however that the Query.populate_existing() method is now + required in order to rewrite the mapper options associated with + an object already loaded in the identity map. + As part of this change, a custom defined MapperOption will now + cause lazy loaders related to the target object to use a non- + baked query by default unless the + MapperOption._generate_cache_key() method is implemented. In + particular, this repairs one regression which occured when + using the dogpile.cache “advanced” example, which was not + returning cached results and instead emitting SQL due to an + incompatibility with the baked query loader; with the change, + the RelationshipCache option included for many releases in the + dogpile example will disable the “baked” query altogether. Note + that the dogpile example is also modernized to avoid both of + these issues as part of issue #4258. References: #4128 + + [orm] [bug] Fixed bug where the new + baked.Result.with_post_criteria() method would not interact + with a subquery-eager loader correctly, in that the “post + criteria” would not be applied to embedded subquery + eager loaders. This is related to #4128 in that the post + criteria feature is now used by the lazy loader. + + [orm] [bug] Updated the dogpile.caching example to include new + structures that accommodate for the “baked” query system, which + is used by default within lazy loaders and some eager + relationship loaders. The dogpile.caching “relationship_caching” + and “advanced” examples were also broken due to #4256. The + issue here is also worked-around by the fix in #4128. + References: #4258 + * engine + + [engine] [bug] Fixed connection pool issue whereby if a + disconnection error were raised during the connection pool’s + “reset on return” sequence in conjunction with an explicit + transaction opened against the enclosing Connection object + (such as from calling Session.close() without a rollback or + commit, or calling Connection.close() without first closing a + transaction declared with Connection.begin()), a double-checkin + would result, which could then lead towards concurrent + checkouts of the same connection. The double-checkin condition + is now prevented overall by an assertion, as well as the + specific double-checkin scenario has been fixed. + References: #4252 + + [engine] [bug] Fixed a reference leak issue where the values of + the parameter dictionary used in a statement execution would + remain referenced by the “compiled cache”, as a result of + storing the key view used by Python 3 dictionary keys(). Pull + request courtesy Olivier Grisel. + * sql + + [sql] [bug] Fixed issue where the “ambiguous literal” error + message used when interpreting literal values as SQL expression + values would encounter a tuple value, and fail to format the + message properly. Pull request courtesy Miguel Ventura. + * mssql + + [mssql] [bug] Fixed a 1.2 regression caused by #4061 where the + SQL Server “BIT” type would be considered to be “native + boolean”. The goal here was to avoid creating a CHECK + constraint on the column, however the bigger issue is that the + BIT value does not behave like a true/false constant and cannot + be interpreted as a standalone expression, e.g. “WHERE + <column>”. The SQL Server dialect now goes back to being non- + native boolean, but with an extra flag that still avoids + creating the CHECK constraint. References: #4250 + * oracle + + [oracle] [bug] The Oracle BINARY_FLOAT and BINARY_DOUBLE + datatypes now participate within cx_Oracle.setinputsizes(), + passing along NATIVE_FLOAT, so as to support the NaN value. + Additionally, oracle.BINARY_FLOAT, oracle.BINARY_DOUBLE and + oracle.DOUBLE_PRECISION now subclass Float, since these are + floating point datatypes, not decimal. These datatypes were + already defaulting the Float.asdecimal flag to False in line + with what Float already does. References: #4264 + + [oracle] [bug] Added reflection capabilities for the + oracle.BINARY_FLOAT, oracle.BINARY_DOUBLE datatypes. + + [oracle] [bug] Altered the Oracle dialect such that when an + Integer type is in use, the cx_Oracle.NUMERIC type is set up + for setinputsizes(). In SQLAlchemy 1.1 and earlier, + cx_Oracle.NUMERIC was passed for all numeric types + unconditionally, and in 1.2 this was removed to allow for + better numeric precision. However, for integers, some + database/client setups will fail to coerce boolean values + True/False into integers which introduces regressive behavior + when using SQLAlchemy 1.2. Overall, the setinputsizes logic + seems like it will need a lot more flexibility going forward so + this is a start for that. References: #4259 + * misc + + [bug] [ext] The horizontal sharding extension now makes use of + the identity token added to ORM identity keys as part of #4137, + when an object refresh or column-based deferred load or + unexpiration operation occurs. Since we know the “shard” that + the object originated from, we make use of this value when + refreshing, thereby avoiding queries against other shards that + don’t match this object’s identity in any case. + References: #4247 + + [bug] [ext] Fixed a race condition which could occur if automap + AutomapBase.prepare() were used within a multi-threaded context + against other threads which may call configure_mappers() as a + result of use of other mappers. The unfinished mapping work of + automap is particularly sensitive to being pulled in by a + configure_mappers() step leading to errors. References: #4266 + + [bug] [tests] Fixed a bug in the test suite where if an + external dialect returned None for server_version_info, the + exclusion logic would raise an AttributeError. + References: #4249 + +------------------------------------------------------------------- Old: ---- SQLAlchemy-1.2.7.tar.gz New: ---- SQLAlchemy-1.2.8.tar.gz fix_test_reflection.patch ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-SQLAlchemy.spec ++++++ --- /var/tmp/diff_new_pack.KayOfl/_old 2018-06-27 10:22:12.806304596 +0200 +++ /var/tmp/diff_new_pack.KayOfl/_new 2018-06-27 10:22:12.810304450 +0200 @@ -20,13 +20,14 @@ %define oldpython python %bcond_without tests Name: python-SQLAlchemy -Version: 1.2.7 +Version: 1.2.8 Release: 0 Summary: Database Abstraction Library License: MIT Group: Development/Languages/Python URL: http://www.sqlalchemy.org Source: https://files.pythonhosted.org/packages/source/S/SQLAlchemy/SQLAlchemy-%{version}.tar.gz +Patch0: fix_test_reflection.patch BuildRequires: %{python_module devel} # Test requirements: BuildRequires: %{python_module mock} @@ -69,6 +70,7 @@ %prep %setup -q -n SQLAlchemy-%{version} +%patch0 -p1 rm -rf doc/build # Remove unnecessary scripts for building documentation sed -i 's/\r$//' examples/dynamic_dict/dynamic_dict.py ++++++ SQLAlchemy-1.2.7.tar.gz -> SQLAlchemy-1.2.8.tar.gz ++++++ ++++ 10569 lines of diff (skipped) ++++++ fix_test_reflection.patch ++++++ >From 871c64221a56e546237e7cf1b2910842027c3531 Mon Sep 17 00:00:00 2001 From: Nils Philippsen <n...@tiptoe.de> Date: Sun, 24 Jun 2018 11:47:05 -0400 Subject: [PATCH] fix TypeReflectionTest for sqlite 3.24 Fixed issue in test suite where SQLite 3.24 added a new reserved word that conflicted with a usage in TypeReflectionTest. Pull request courtesy Nils Philippsen. Change-Id: I396562cecb5ca774f29e9234845bcc6a399fc5cb Pull-request: https://github.com/zzzeek/sqlalchemy/pull/452 (cherry picked from commit 40a5d0a4b006780167976b296984eb9790f3df7f) --- doc/build/changelog/unreleased_12/pr452.rst | 7 +++++++ test/dialect/test_sqlite.py | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) create mode 100644 doc/build/changelog/unreleased_12/pr452.rst diff --git a/doc/build/changelog/unreleased_12/pr452.rst b/doc/build/changelog/unreleased_12/pr452.rst new file mode 100644 index 0000000..471b203 --- /dev/null +++ b/doc/build/changelog/unreleased_12/pr452.rst @@ -0,0 +1,7 @@ +.. change:: + :tags: bug, sqlite + :versions: 1.3.0b1 + + Fixed issue in test suite where SQLite 3.24 added a new reserved word that + conflicted with a usage in TypeReflectionTest. Pull request courtesy Nils + Philippsen. diff --git a/test/dialect/test_sqlite.py b/test/dialect/test_sqlite.py index 4c462ae..d2d5632 100644 --- a/test/dialect/test_sqlite.py +++ b/test/dialect/test_sqlite.py @@ -1637,7 +1637,7 @@ class TypeReflectionTest(fixtures.TestBase): ("BLOBBER", sqltypes.NullType()), ("DOUBLE PRECISION", sqltypes.REAL()), ("FLOATY", sqltypes.REAL()), - ("NOTHING WE KNOW", sqltypes.NUMERIC()), + ("SOMETHING UNKNOWN", sqltypes.NUMERIC()), ] def _fixture_as_string(self, fixture): -- 2.10.5
