Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "What does `platform.machine()` return on that hardware, out of curiosity? I'm sure this is just an endianness thing, so we can just add a conditional to skip the test.", "```\r\n>>> platform.machine()\r\n's390x'\r\n```", "Just FYI I tagged a new release, 3.15.3." ]

[]

[]

[ "Do you see your materialized view when running:\r\n\r\n```sql\r\nselect viewname, definition from pg_catalog.pg_views \r\nwhere schemaname = 'public' order by tablename; -- change schema name if differs\r\n```", "Oh wait, nevermind, I see that they're listed separately in `pg_catalog.pg_matviews`.", "For now I'm going to hold off on implementing this, as our standard way of introspecting the columns associated with a table (or non-materialized view) does not seem to work with materialized views. With regular tables or views, we can run something like:\r\n\r\n```sql\r\nselect column_name, is_nullable, data_type, column_default\r\nfrom information_schema.columns\r\nwhere table_name = 'the table or view name'\r\n```\r\n\r\nUnfortunately, it looks like the process for introspecting a materialized view is different, see: https://stackoverflow.com/questions/39179253/postgresql-get-materialized-view-column-metadata\r\n\r\nFor now you'll just want to create these manually.", "If the view you are manually defining does not have a primary key - read about [models without a primary key](https://docs.peewee-orm.com/en/latest/peewee/models.html#models-without-a-primary-key)\r\n\r\neg.\r\n\r\n class MyMaterializedView(BaseModel):\r\n ...\r\n \r\n class Meta:\r\n primary_key = False\r\n" ]

[]

[]

[ "I wonder if this is a regression in the standard lib sqlite3. Is it possible for you to also try pip installing `pysqlite3` and see if the test passes? Peewee should try to use pysqlite3, you can check by running:\r\n\r\n```\r\nfrom peewee import sqlite3\r\nprint(sqlite3)\r\n```\r\n\r\nThis should hopefully be pysqlite3.", "Trying to install pysqlite3 with pip seems to fail, even though it says success.\r\n\r\n```\r\n(py311) [root@f37-container:~/peewee]# pip install pysqlite3\r\nCollecting pysqlite3\r\n Using cached pysqlite3-0.4.7.tar.gz (40 kB)\r\n Preparing metadata (setup.py) ... done\r\nBuilding wheels for collected packages: pysqlite3\r\n Building wheel for pysqlite3 (setup.py) ... done\r\n WARNING: Legacy build of wheel for 'pysqlite3' created no files.\r\n Command arguments: /root/peewee/py311/bin/python3.11 -u -c '\r\n exec(compile('\"'\"''\"'\"''\"'\"'\r\n # This is <pip-setuptools-caller> -- a caller that pip uses to run setup.py\r\n #\r\n # - It imports setuptools before invoking setup.py, to enable projects that directly\r\n # import from `distutils.core` to work with newer packaging standards.\r\n # - It provides a clear error message when setuptools is not installed.\r\n # - It sets `sys.argv[0]` to the underlying `setup.py`, when invoking `setup.py` so\r\n # setuptools doesn'\"'\"'t think the script is `-c`. This avoids the following warning:\r\n # manifest_maker: standard file '\"'\"'-c'\"'\"' not found\".\r\n # - It generates a shim setup.py, for handling setup.cfg-only projects.\r\n import os, sys, tokenize\r\n \r\n try:\r\n import setuptools\r\n except ImportError as error:\r\n print(\r\n \"ERROR: Can not execute `setup.py` since setuptools is not available in \"\r\n \"the build environment.\",\r\n file=sys.stderr,\r\n )\r\n sys.exit(1)\r\n \r\n __file__ = %r\r\n sys.argv[0] = __file__\r\n \r\n if os.path.exists(__file__):\r\n filename = __file__\r\n with tokenize.open(__file__) as f:\r\n setup_py_code = f.read()\r\n else:\r\n filename = \"<auto-generated setuptools caller>\"\r\n setup_py_code = \"from setuptools import setup; setup()\"\r\n \r\n exec(compile(setup_py_code, filename, \"exec\"))\r\n '\"'\"''\"'\"''\"'\"' % ('\"'\"'/tmp/pip-install-kkm14zbf/pysqlite3_fce9f2061a1141be9cb19473624dd0c8/setup.py'\"'\"',), \"<pip-setuptools-caller>\", \"exec\"))' bdist_wheel -d /tmp/pip-wheel-am9z47vw\r\n Command output: [use --verbose to show]\r\n Running setup.py clean for pysqlite3\r\nFailed to build pysqlite3\r\nInstalling collected packages: pysqlite3\r\n Running setup.py install for pysqlite3 ... done\r\nSuccessfully installed pysqlite3\r\n(py311) [root@f37-container:~/peewee]# pip list\r\nPackage Version\r\n---------- -------\r\nCython 0.29.32\r\npip 22.2.2\r\nsetuptools 65.3.0\r\nwheel 0.37.1\r\n```", "Hmm, I'm not sure what to try besides:\r\n\r\n```\r\ngit clone https://github.com/coleifer/pysqlite3\r\ncd pysqlite3\r\npython setup.py build\r\npython setup.py install\r\n```\r\n\r\nThat at least may give an indication of the issue?", "It doesn't seem pysqlite3 likes Python 3.11.\r\n\r\n```\r\n(py311) [root@f37-container:~/pysqlite3]# python setup.py build\r\nrunning build\r\nrunning build_py\r\ncreating build\r\ncreating build/lib.linux-x86_64-cpython-311\r\ncreating build/lib.linux-x86_64-cpython-311/pysqlite3\r\ncopying pysqlite3/__init__.py -> build/lib.linux-x86_64-cpython-311/pysqlite3\r\ncopying pysqlite3/dbapi2.py -> build/lib.linux-x86_64-cpython-311/pysqlite3\r\nrunning build_ext\r\nBuilds a C extension linking against libsqlite3 library\r\nbuilding 'pysqlite3._sqlite3' extension\r\ncreating build/temp.linux-x86_64-cpython-311\r\ncreating build/temp.linux-x86_64-cpython-311/src\r\ngcc -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -DMODULE_NAME=\\\"pysqlite3.dbapi2\\\" -I/usr/include -I/root/peewee/py311/include -I/usr/include/python3.11 -c src/blob.c -o build/temp.linux-x86_64-cpython-311/src/blob.o\r\ngcc -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -DMODULE_NAME=\\\"pysqlite3.dbapi2\\\" -I/usr/include -I/root/peewee/py311/include -I/usr/include/python3.11 -c src/cache.c -o build/temp.linux-x86_64-cpython-311/src/cache.o\r\ngcc -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -DMODULE_NAME=\\\"pysqlite3.dbapi2\\\" -I/usr/include -I/root/peewee/py311/include -I/usr/include/python3.11 -c src/connection.c -o build/temp.linux-x86_64-cpython-311/src/connection.o\r\nsrc/connection.c: In function ‘_pysqlite_step_callback’:\r\nsrc/connection.c:725:31: warning: implicit declaration of function ‘_PyObject_CallNoArg’; did you mean ‘PyObject_CallNoArgs’? [-Wimplicit-function-declaration]\r\n 725 | *aggregate_instance = _PyObject_CallNoArg(aggregate_class);\r\n | ^~~~~~~~~~~~~~~~~~~\r\n | PyObject_CallNoArgs\r\nsrc/connection.c:725:29: warning: assignment to ‘PyObject *’ {aka ‘struct _object *’} from ‘int’ makes pointer from integer without a cast [-Wint-conversion]\r\n 725 | *aggregate_instance = _PyObject_CallNoArg(aggregate_class);\r\n | ^\r\nsrc/connection.c: In function ‘_progress_handler’:\r\nsrc/connection.c:1175:9: warning: assignment to ‘PyObject *’ {aka ‘struct _object *’} from ‘int’ makes pointer from integer without a cast [-Wint-conversion]\r\n 1175 | ret = _PyObject_CallNoArg((PyObject*)user_arg);\r\n | ^\r\ngcc -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -DMODULE_NAME=\\\"pysqlite3.dbapi2\\\" -I/usr/include -I/root/peewee/py311/include -I/usr/include/python3.11 -c src/cursor.c -o build/temp.linux-x86_64-cpython-311/src/cursor.o\r\ngcc -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -DMODULE_NAME=\\\"pysqlite3.dbapi2\\\" -I/usr/include -I/root/peewee/py311/include -I/usr/include/python3.11 -c src/microprotocols.c -o build/temp.linux-x86_64-cpython-311/src/microprotocols.o\r\ngcc -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -DMODULE_NAME=\\\"pysqlite3.dbapi2\\\" -I/usr/include -I/root/peewee/py311/include -I/usr/include/python3.11 -c src/module.c -o build/temp.linux-x86_64-cpython-311/src/module.o\r\ngcc -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -DMODULE_NAME=\\\"pysqlite3.dbapi2\\\" -I/usr/include -I/root/peewee/py311/include -I/usr/include/python3.11 -c src/prepare_protocol.c -o build/temp.linux-x86_64-cpython-311/src/prepare_protocol.o\r\nsrc/prepare_protocol.c: In function ‘pysqlite_prepare_protocol_setup_types’:\r\nsrc/prepare_protocol.c:81:43: error: lvalue required as left operand of assignment\r\n 81 | Py_TYPE(&pysqlite_PrepareProtocolType)= &PyType_Type;\r\n | ^\r\nerror: command '/usr/bin/gcc' failed with exit code 1\r\n```\r\n\r\nThis is with gcc 12.2.1 if that matters.", "Thank you, I'll investigate tomorrow. I only wanted to check because we've found a different regression in the 3.11 sqlite3.", "Thanks, I appreciate it. Let me know if I can try any other scenarios to pin it down. Fedora packages multiple Python runtimes and it's easy to spin up various Fedora versions in containers to try different combinations of things.", "I tried one more combination that might be interesting to you. Using Fedora 36 with Python 3.10.6 and sqlite 3.36.0, I was able to reproduce the same error but with a stack trace this time.\r\n\r\n```\r\n======================================================================\r\nERROR: test_insert_behavior (tests.sqlite.TestSqliteReturningConfig)\r\n----------------------------------------------------------------------\r\nTraceback (most recent call last):\r\n File \"/root/peewee/peewee.py\", line 3221, in execute_sql\r\n cursor.execute(sql, params or ())\r\nsqlite3.OperationalError: database table is locked\r\n\r\nDuring handling of the above exception, another exception occurred:\r\n\r\nTraceback (most recent call last):\r\n File \"/root/peewee/tests/base.py\", line 246, in tearDown\r\n self.database.drop_tables(self.requires, safe=True)\r\n File \"/root/peewee/peewee.py\", line 3417, in drop_tables\r\n model.drop_table(**kwargs)\r\n File \"/root/peewee/peewee.py\", line 6845, in drop_table\r\n cls._schema.drop_all(safe, drop_sequences, **options)\r\n File \"/root/peewee/peewee.py\", line 5949, in drop_all\r\n self.drop_table(safe, **options)\r\n File \"/root/peewee/peewee.py\", line 5818, in drop_table\r\n self.database.execute(self._drop_table(safe=safe, **options))\r\n File \"/root/peewee/peewee.py\", line 3234, in execute\r\n return self.execute_sql(sql, params, commit=commit)\r\n File \"/root/peewee/peewee.py\", line 3218, in execute_sql\r\n with __exception_wrapper__:\r\n File \"/root/peewee/peewee.py\", line 2994, in __exit__\r\n reraise(new_type, new_type(exc_value, *exc_args), traceback)\r\n File \"/root/peewee/peewee.py\", line 191, in reraise\r\n raise value.with_traceback(tb)\r\n File \"/root/peewee/peewee.py\", line 3221, in execute_sql\r\n cursor.execute(sql, params or ())\r\npeewee.OperationalError: database table is locked\r\n\r\n======================================================================\r\nFAIL: test_insert_behavior (tests.sqlite.TestSqliteReturningConfig)\r\n----------------------------------------------------------------------\r\nTraceback (most recent call last):\r\n File \"/root/peewee/tests/sqlite.py\", line 2506, in test_insert_behavior\r\n self.assertEqual(iq.execute(), 2)\r\nAssertionError: 0 != 2\r\n\r\n----------------------------------------------------------------------\r\n```\r\n\r\nIn this environment I was able to pip install pysqlite3, and it caused the tests to pass.", "I think you're right about this being a regression. I spun up a Fedora 36 container with Python 3.10.5, and the tests pass there (without pysqlite3). I think something changed between 3.10.5 and 3.10.6 that is also in 3.11.0rc2.", "cc @erlend-aasland if you see this", "> cc @erlend-aasland if you see this\n\nThanks for the heads-up; highly appreciated. I'll take a look as soon as I am back at my laptop.", "I'll try to get a minimal reproduction -- it looks at first glance like an issue with the `cursor.rowcount`. Compiling python 3.11 now and will update here once I've figured out how to reproduce this w/stdlib sqlite3 (if indeed that's the culprit).", "Well it's very strange and I'm not at all sure now that it's a regression. It looks to do in part with cached statements and the use of `returning`. In all likelihood it may be that the behavior of Python 3.11 is correct, but I'll leave that to you to determine @erlend-aasland.\r\n\r\nHere is what the test is doing:\r\n\r\n```python\r\nimport sqlite3\r\n\r\nconn = sqlite3.connect(':memory:')\r\nconn.execute('create table \"t1\" (\"id\" integer not null primary key, '\r\n '\"col\" text not null)')\r\n \r\ncurs = conn.execute('insert into \"t1\" (\"col\") values (?), (?) returning \"id\"',\r\n ('u1', 'u2'))\r\ncurs.fetchall() # Here we consume the cursor during the test.\r\n\r\n# Same query as above.\r\ncurs = conn.execute('insert into \"t1\" (\"col\") values (?), (?) returning \"id\"',\r\n ('u3', 'u4'))\r\nassert curs.rowcount == 2\r\n```\r\n\r\nThe thing that threw me off trying to replicate, however, is that during that first insert query, the returned rowcount is actually 0 on Python < 3.11:\r\n\r\n```python\r\n# For example, on python 3.7, the following raises no assertion errors:\r\n# ... create table, same as above ...\r\ncurs = conn.execute('insert into \"t1\" (\"col\") values (?), (?) returning \"id\"',\r\n ('u1', 'u2'))\r\nassert curs.rowcount == 0 # Here the rowcount is 0 (!!)\r\ncurs.fetchall() # Here we consume the cursor during the test.\r\nassert curs.rowcount == 0 # Here the rowcount is STILL 0\r\n\r\n# Same query as above.\r\ncurs = conn.execute('insert into \"t1\" (\"col\") values (?), (?) returning \"id\"',\r\n ('u3', 'u4'))\r\nassert curs.rowcount == 2 # Here the rowcount is 2\r\n```\r\n\r\nOn, e.g. Python 3.7 -- if we do *not* consume the cursor in between the executions, then the second insert's rowcount is also 0:\r\n\r\n```python\r\n# For example, on python 3.7, the following raises no assertion errors:\r\n# ... create table, same as above ...\r\ncurs = conn.execute('insert into \"t1\" (\"col\") values (?), (?) returning \"id\"',\r\n ('u1', 'u2'))\r\nassert curs.rowcount == 0 # Here the rowcount is 0 (!!)\r\n\r\n# Same query as above.\r\ncurs = conn.execute('insert into \"t1\" (\"col\") values (?), (?) returning \"id\"',\r\n ('u3', 'u4'))\r\nassert curs.rowcount == 0 # Here the rowcount is also 0\r\n```\r\n\r\nOn Python 3.11, though, the rowcount is always `0`:\r\n\r\n```python\r\n# On python 3.11, the following raises no assertion errors:\r\n# ... create table, same as above ...\r\ncurs = conn.execute('insert into \"t1\" (\"col\") values (?), (?) returning \"id\"',\r\n ('u1', 'u2'))\r\nassert curs.rowcount == 0 # Here the rowcount is 0\r\ncurs.fetchall() # Here we consume the cursor during the test.\r\n\r\n# Same query as above.\r\ncurs = conn.execute('insert into \"t1\" (\"col\") values (?), (?) returning \"id\"',\r\n ('u3', 'u4'))\r\nassert curs.rowcount == 0 # Here the rowcount is also 0\r\n```\r\n\r\n----------------------------------------------------------------\r\n\r\nIt seems like my test unintentionally revealed some inconsistency in the way the rowcount is being handled, and possibly there is some interplay in the way the statement cache works, because of the way it manifests differently during the second execution.", "@carlwgeorge - I've put in a very minimal skip directive to get your build passing for now: 49a64bd23591cd96f8ba832646ccac3256481325\r\n\r\nI also have pysqlite3 fixed-up and working on `master`, thanks for sharing those tracebacks with me.\r\n\r\n**Update:** I've removed the faulty assertions in light of sqlite3's behavior checked directly in my comment below - commit 73335396e0336332832e52d4d7272b7d1ed9e794", "Looks like this has to do with how Sqlite itself handles `sqlite3_changes()` interface when the insert query has a RETURNING clause:\r\n\r\n```c\r\n#include <stdio.h>\r\n#include <sqlite3.h>\r\n\r\nint main(int argc, char *argv[]) {\r\n sqlite3 *db;\r\n sqlite3_stmt *stmt;\r\n\r\n sqlite3_open(\":memory:\", &db);\r\n sqlite3_exec(db, \"create table t1 (id integer not null primary key, col text not null);\", NULL, NULL, NULL);\r\n sqlite3_prepare_v2(db, \"insert into t1 (col) values (?), (?) returning id\", -1, &stmt, NULL);\r\n sqlite3_bind_text(stmt, 1, \"u1\", -1, NULL);\r\n sqlite3_bind_text(stmt, 2, \"u2\", -1, NULL);\r\n int rc = sqlite3_step(stmt);\r\n printf(\"changes: %d\\n\", sqlite3_changes(db));\r\n if (rc != SQLITE_DONE) {\r\n do {\r\n printf(\"%d\\n\", sqlite3_column_int(stmt, 0));\r\n rc = sqlite3_step(stmt);\r\n } while (rc != SQLITE_DONE);\r\n }\r\n printf(\"changes: %d\\n\", sqlite3_changes(db));\r\n}\r\n```\r\n\r\nOutput is:\r\n\r\n```\r\nchanges: 0\r\n1\r\n2\r\nchanges: 2\r\n```", "I'm going to close this as it seems that, if anything, Python 3.11 has it correct and the test was only passing due to a side-effect (as far as I can tell) of the statement cache. The faulty assertions are removed from our tests.", "Thank you so much for the quick investigation and resolution for this. I've added 73335396e0336332832e52d4d7272b7d1ed9e794 as a patch to the Fedora package update I'm working on.", "Sorry for not getting back to you, Charles! (I've spent most of the last two weeks on the road, with very fragmented online precence.)\r\n\r\nYeah, the INSERT/UPDATE ... RETURNING thing! We had an issue about that in CPython some months ago. Fixed in `main` (and possibly also backported to 3.11 and 3.10).", "FWIW, here's what I used to debug the related issues:\r\n\r\n- https://gist.github.com/erlend-aasland/98b41dab6cc51c1082c70eef3659d8d1\r\n- https://gist.github.com/erlend-aasland/5e48b920d882e04f911fe7871fd5ccd9\r\n\r\nI don't like the sqlite3_changes() API... :)", "Hope you had a nice adventure, thanks for the links on the debug scripts. I came to the same conclusion as you, which was that we can't determine the modified rowcount until everything returned by `RETURNING` has been stepped-through." ]

[]

[]

[ "Sorry, that's not going to work, as we overload those already for the creation of expressions. This would require treating expression objects differently in the context of the `.join()` method. The way you've got `.on()` and the absence of parentheses presents even more difficulties.", "Sorry, but I don't see the problem. \r\n`User.t` - `t` - is not the field, but magic model self-reference, so it doesn't overlap with field-expressions\r\n\r\nHere is dirty but working example to demonstrate the concept:\r\n```python\r\nimport os\r\nfrom peewee import *\r\nimport datetime\r\n\r\nfp = os.path.join(os.path.dirname(__file__), 'my_database.db')\r\n\r\n\r\ndb = SqliteDatabase(fp)\r\n\r\n\r\nclass ModelRef:\r\n def __init__(self, cls):\r\n self._cls = cls\r\n self._right = None\r\n self._join_type = None\r\n self._on = None\r\n\r\n def __and__(self, model_to_join):\r\n self._join_type = JOIN.INNER\r\n self._right = model_to_join\r\n return self\r\n\r\n def on(self, expression):\r\n self._on = expression\r\n return self\r\n\r\n def __call__(self):\r\n return (\r\n self._right._cls,\r\n self._join_type,\r\n self._right._on,\r\n )\r\n\r\n\r\nclass BaseModel(Model):\r\n\r\n # should be @classproperty\r\n @classmethod\r\n def t(cls):\r\n return ModelRef(cls)\r\n\r\n class Meta:\r\n database = db\r\n\r\n\r\nclass User(BaseModel):\r\n username = CharField(unique=True)\r\n\r\n\r\nclass Tweet(BaseModel):\r\n user = ForeignKeyField(User, backref='tweets')\r\n message = TextField()\r\n created_date = DateTimeField(default=datetime.datetime.now)\r\n is_published = BooleanField(default=True)\r\n\r\n\r\nquery = (\r\n User\r\n .select(User, Tweet)\r\n .join(*(\r\n User.t()\r\n & Tweet.t().on(Tweet.user == User.id)\r\n )())\r\n)\r\n\r\nprint(query)\r\n\r\n```", "@coleifer so it only requires proper `ModelRef` implementation and `isinstance(dest, ModelRef)`-logic in `ModelSelect.join`-method" ]

[]

[]

[ "I don't know that we're able to do this, actually:\r\n\r\n```python\r\nIn [1]: class Expr(object):\r\n ...: def __init__(self, lhs, op, rhs):\r\n ...: self.lhs, self.op, self.rhs = lhs, op, rhs\r\n ...: def __str__(self):\r\n ...: return '%s %s %s' % (self.lhs, self.op, self.rhs)\r\n ...: def __le__(self, other):\r\n ...: return Expr(self, '<=', other)\r\n ...: def __ge__(self, other):\r\n ...: return Expr(self, '>=', other)\r\n ...: \r\n\r\nIn [2]: e = Expr(None, None, None)\r\n\r\nIn [3]: print(2 <= e <= 5)\r\nNone None None <= 5\r\n```\r\n\r\nSee how the first comparison (2 <= e) is lost?\r\n\r\nThe best you can get is to use parentheses, but the semantics change and will not be correct:\r\n\r\n```python\r\nIn [5]: print((2 <= e) <= 5)\r\nNone None None >= 2 <= 5\r\n```\r\n\r\nAnyways, you should probably be using `.between()` anyways, as some databases are able to optimize this:\r\n\r\n```python\r\nM.select(M.id).where(M.id.between(2, 3))\r\n```\r\n", "Indeed, this is impossible to implement in Python. I'm surprised.\r\n\r\n```\r\n>>> dis.disassemble((lambda: x <= y < z).__code__)\r\n 1 0 LOAD_GLOBAL 0 (x)\r\n 2 LOAD_GLOBAL 1 (y)\r\n 4 DUP_TOP\r\n 6 ROT_THREE\r\n 8 COMPARE_OP 1 (<=)\r\n 10 JUMP_IF_FALSE_OR_POP 9 (to 18)\r\n 12 LOAD_GLOBAL 2 (z)\r\n 14 COMPARE_OP 0 (<)\r\n 16 RETURN_VALUE\r\n >> 18 ROT_TWO\r\n 20 POP_TOP\r\n 22 RETURN_VALUE\r\n```\r\n\r\nThe result of one of the comparisons will always be ignored (8 -> 10 -> 18 => second comparison never executed; or 8 -> 10 -> 12 => result of first comparison is dropped).", "Thank you for your comment Jonas, very nice debugging and a better explanation than the one I provided." ]

[]

[]

[ "I'm not going to do your homework for you, but there is a ton of discussion on this on the web. Some of it depends on what database you use, postgres probably being the most commonly discussed.\r\n\r\n* https://github.com/que-rb/que - https://github.com/que-rb/que/blob/master/lib/que/poller.rb#L60-L113\r\n* https://github.com/QueueClassic/queue_classic - https://github.com/QueueClassic/queue_classic/blob/master/lib/queue_classic/queue.rb#L92-L111", "If you're looking for something simpler, you can always refer to this, which is Peewee-specific:\r\n\r\nhttps://github.com/coleifer/huey/blob/master/huey/contrib/sql_huey.py", "> I'm not going to do your homework for you, but there is a ton of discussion on this on the web.\r\n\r\nDude, I've been a software developer for nearly 20 years in embedded land. It's possible one can be a novice to databases and also not a student, at the same time." ]

[]

[]

[ "This looks like some issue with your debugger / pycharm. The `__len__()` / `count` behavior is covered by unit tests. `peewee.fn` is an instance of `Function` and implements some magic -- possibly your debugger is shadowing the `fn` name. Not sure.", "I think that must be something to do with it. I tried renaming global 'fn' to 'fn_p' in peewee.py and it succeeded, so it does seem to being overwritten. I've tried tracing this through a bit and it seems that during the initialisation of the `SqliteExtDatabase` the registering of the cython rank functions results in the global fn being overwritten. I cannot understand how this would be happening. " ]

[]

[]

[ "No problem, fixed." ]

[]

[]

[ "There are a few issues with your patch - it consumes the entire cursor in one go and returns a list, when it would probably be better suited to use a generator. Similarly, it is not carrying through the `database` parameter. I will implement a similar patch and merge it.", "Thank you!" ]

[]

[]

[ "Sorry, I just found #2504. Closing." ]

[]

[]

[ "The query seems to work fine for the `name` column but it does not appear to be working with the JSON type.\r\n\r\n```python\r\nReg.insert_many(\r\n [\r\n {\"id\": 1, \"name\": \"bar \\\\ 1\", \"message\": [\"a \\\\ b\"]},\r\n {\"id\": 2, \"name\": \"bar\", \"message\": [\"a \\\\\\\\ b\"]},\r\n ]\r\n).execute()\r\n\r\nkey = \"\\\\\"\r\n\r\n# This query against the name column works fine.\r\nquery = Reg.select(Reg.name).where(Reg.name.contains(key))\r\nprint('name like')\r\nfor r in query:\r\n print(r.name)\r\n\r\n# This query against the message (json) column does not.\r\nquery = Reg.select(Reg.name).where(Reg.message.contains(key))\r\nprint('message like')\r\nfor r in query: # peewee.OperationalError: (1210, 'Incorrect arguments to ESCAPE')\r\n print(r.name)\r\n```\r\n\r\nFurthermore, I think using `LIKE` against a JSON data-type is probably not something advisable. Are you using MySQL from Oracle, or MariaDB? It might be better in any case to use the built-in JSON functions or extract the text value from the JSON object and query it that way.\r\n\r\n```python\r\n\r\n# This works just fine:\r\nquery = Reg.select(Reg.name).where(fn.json_extract(Reg.message, '$[0]').contains(key))\r\n\r\n# SELECT `t1`.`name` FROM `reg` AS `t1`\r\n# WHERE (json_extract(`t1`.`message`, '$[0]') LIKE '%\\\\%' ESCAPE '\\')\r\nfor r in query: # works fine.\r\n print(r.name)\r\n```\r\n\r\nBasically, I think you're misusing the JSON data-type and should instead either:\r\n\r\n1. Use a plain TEXT / LONGTEXT column to store the json data, or\r\n2. Use the JSON functions to extract the text value first, then do the LIKE", "@coleifer Using the `LIKE` with JSON field in the MySQL is still a valid solution when we want to include keywords in some generic search functionality, especially when we have to find bad characters in heterogeneous JSON documents by specific signature to replace in the database migrations. My example above was simplified just for the test.", "In addition to this if we even used the `TEXT` field to keep JSON data we would write the following:\r\n```python\r\n#!/usr/bin/env python\r\n\r\nimport json\r\nfrom peewee import *\r\n\r\n\r\ndb = MySQLDatabase(\r\n \"db\", host=\"localhost\", port=3306, user=\"user\", password=\"password\"\r\n)\r\n\r\n\r\nclass JsonTextField(TextField):\r\n def db_value(self, value):\r\n if value is not None:\r\n return json.dumps(value)\r\n\r\n def python_value(self, value):\r\n if value is not None:\r\n return json.loads(value)\r\n\r\n\r\nclass t1(Model):\r\n id = IntegerField(primary_key=True)\r\n name = CharField(255)\r\n message = JsonTextField()\r\n\r\n class Meta:\r\n database = db\r\n db_table = \"t1\"\r\n\r\n\r\ndb.connect()\r\ndb.create_tables([t1])\r\nt1.truncate_table()\r\nt1.insert_many(\r\n [\r\n {\"id\": 1, \"name\": \"bar\", \"message\": [\"a \\\\ b\"]},\r\n {\"id\": 2, \"name\": \"bar\", \"message\": [\"a \\\\\\\\ b\"]},\r\n ]\r\n).execute()\r\n\r\nkey = \"\\\\\"\r\n\r\nquery = t1.select(t1.name).where(t1.name.contains(key) | t1.message.contains(key))\r\n\r\nprint(query)\r\nfor r in query:\r\n print(r)\r\n\r\n```\r\n\r\nIt produces the same error:\r\n```sql\r\nSELECT `t1`.`name` FROM `t1` AS `t1` WHERE ((`t1`.`name` LIKE '%\\\\\\\\%' ESCAPE '\\\\') OR (`t1`.`message` LIKE '\\\"%\\\\\\\\\\\\\\\\%\\\"' ESCAPE '\\\"\\\\\\\\\\\"'))\r\n```", "Aha, thank you for your persistence -- I spotted the bug. The escape sequence is being handled by the Json converter, which dumps these strings as json and creates invalid escapes.\r\n\r\nThis should be fixed in master now.", "3.15.2 released now, which contains this fix." ]

[]

[]

[ "Prefetch does not expose a query because the results are not composed of a single query, but rather `k` queries for however many tables are being prefetched. Dependent rows are iterated and an in-memory map is built for efficiently assigning them to their parent model instance/row. They're not able to be composed like your usual peewee queries.\r\n\r\nAlso note, I'd advise profiling to make sure `prefetch()` is actually faster in your case. It will likely come down to the ratio of the sizes of your outermost -> innermost loops whether it even provides a speedup or not.", "What's the value of `pq.query` before it's wrapped in a list [here](https://github.com/coleifer/peewee/blob/b36aea92d5c111278a9d0649afab89f9f1ffe0ac/peewee.py#L7934)?", "These lines are more relevant https://github.com/coleifer/peewee/blob/b36aea92d5c111278a9d0649afab89f9f1ffe0ac/peewee.py#L7927-L7932 but that is the outermost query, which has already been consumed and all the cached row instances in its CursorWrapper have their related child-instances populated, and so-on down the chain." ]

[]

[]

[ "Here's an example. You can use `Meta.table_settings`:\r\n\r\nhttps://github.com/coleifer/peewee/blob/master/tests/schema.py#L433-L448\r\n\r\n```python\r\n def test_table_settings(self):\r\n class KVSettings(TestModel):\r\n key = TextField(primary_key=True)\r\n value = TextField()\r\n timestamp = TimestampField()\r\n class Meta:\r\n database = self.database\r\n table_settings = ('PARTITION BY RANGE (timestamp)',\r\n 'WITHOUT ROWID')\r\n self.assertCreateTable(KVSettings, [\r\n ('CREATE TABLE \"kv_settings\" ('\r\n '\"key\" TEXT NOT NULL PRIMARY KEY, '\r\n '\"value\" TEXT NOT NULL, '\r\n '\"timestamp\" INTEGER NOT NULL) '\r\n 'PARTITION BY RANGE (timestamp) '\r\n 'WITHOUT ROWID')])\r\n```\r\n\r\nDoc of model metadata options (scroll to table): http://docs.peewee-orm.com/en/latest/peewee/models.html#model-options-and-table-metadata" ]

[]

[]

[ "We don't want to raise an IndexError since it is not inherently an iterable type, so I'm going with NotImplementedError for now.", "3.15.2 released now, which contains this fix." ]

[]

[]

[ "You are welcome to write your own implementation and place it on a `Base` model class you use." ]

[]

[]

[ "`get()` is a classmethod. Check out the following:\r\n\r\n```python\r\nclass BaseModel(Model):\r\n @classmethod\r\n def get(cls, *query, **filters):\r\n print('get() called on base.')\r\n return super(BaseModel, cls).get(*query, **filters)\r\n class Meta:\r\n database = db\r\n\r\nclass User(BaseModel):\r\n username = TextField()\r\n\r\ndb.create_tables([User])\r\nUser.create(username='u1')\r\nprint(User.get(User.username == 'u1').username)\r\nprint(User.get(username='u1').username)\r\n```\r\n\r\nOutput:\r\n\r\n```\r\nget() called on base.\r\nu1\r\nget() called on base.\r\nu1\r\n```" ]

[]

[]

[ "Going to pass for now, thanks." ]

[]

[]

[ "What I'm expecting is this:\r\n```json\r\n{\r\n \"attached_file\": { \"file_name\": \"test.jpg\", \"file_url\": null }\r\n}\r\n```\r\nnot this:\r\n```json\r\n{\r\n \"attached_file\": { \"file_name\": \"test.jpg\" }\r\n \"file_url\": null\r\n}\r\n```\r\n\r\nI think Peewee should automatically handle such \"calls\":\r\n```python3\r\nCase(...).alias(AttachedFile.file_url)\r\n```", "I note one strange thing about your example -- why is there a circular foreign-key between AttachedFile and Article? Also there seems to be no fk between User and Article, though that's referenced in your example. Overall I think everything is behaving very normally in the following example:\r\n\r\n```python\r\nclass AttachedFile(Base):\r\n file_name = TextField() # this is public\r\n file_url = TextField() # but this field requires users to be subscribed\r\n\r\nclass Article(Base):\r\n attached_file = ForeignKeyField(AttachedFile)\r\n\r\nclass User(Base):\r\n username = TextField\r\n\r\nclass Subscription(Base):\r\n user = ForeignKeyField(User)\r\n\r\ndb.create_tables([AttachedFile, Article, User, Subscription])\r\n\r\nu1, u2, u3 = [User.create(username=u) for u in ('u1', 'u2', 'u3')]\r\nSubscription.create(user=u3)\r\n\r\naf1 = AttachedFile.create(file_name='af1', file_url='https://af1')\r\naf2 = AttachedFile.create(file_name='af2', file_url='https://af2')\r\n\r\na1 = Article.create(attached_file=af1)\r\na2 = Article.create(attached_file=af2)\r\n\r\ndef show_attached(uid):\r\n sub_cte = Subscription.select().where(Subscription.user == uid).cte('sub_cte')\r\n sel = (AttachedFile.id,\r\n AttachedFile.file_name,\r\n Case(fn.EXISTS(sub_cte.select()),\r\n [(False, None)],\r\n AttachedFile.file_url).alias('file_url'))\r\n q = (Article\r\n .select(*sel)\r\n .join_from(Article, AttachedFile)\r\n .with_cte(sub_cte))\r\n return q\r\n\r\n# For user-2 there is no subscription, so file url is None:\r\nfor row in show_attached(u2.id):\r\n print(row.attached_file.file_name, row.file_url)\r\n\r\n# For user-3 there is a subscription, so file url is shown:\r\nfor row in show_attached(u3.id):\r\n print(row.attached_file.file_name, row.file_url)\r\n```\r\n\r\nIt sounds like the crux of the issue is that you want the `file_url` patched onto the related `AttachedFile` instance? Unfortunately, Peewee does not have a way to specify which model in the model-graph the aliased `Case` should be applied-to. Why not select from `AttachedFile`, though, since that seems to be the only data you're interested in? Alternatively, you can handle setting the attributes yourself when serializing or iterating. Lastly, you can use the `.objects()` query-chaining method to apply all selected columns onto the `Article`, or use `.dicts()` to get a flat dictionary of the selected data.\r\n\r\nHere's how I would do it, though:\r\n\r\n```python\r\n q = (AttachedFile\r\n .select(*sel)\r\n .join_from(AttachedFile, Article)\r\n .with_cte(sub_cte))\r\n\r\n...\r\n\r\nfor row in show_attached(u3.id):\r\n print(row.file_name, row.file_url)\r\n```\r\n\r\nI do agree it would be nice to support a way to specify which model an arbitrary expression gets bound-to, but that would require some new APIs as I believe a great many existing implementations rely on the current behavior, and in 12 years this is the first time this has been requested. So I am going to hold-off for now, but will give it some thought and post here if anything should change.", ">I note one strange thing about your example -- why is there a circular foreign-key between AttachedFile and Article? Also there seems to be no fk between User and Article, though that's referenced in your example. Overall I think everything is behaving very normally in the following example:\r\n\r\nYeah, that piece of code is just to give some context.\r\n\r\nThanks for the detailed answer! I'll try that.", "Added a new little helper in `master` eeff376be5af089e7d3849284a1c1d71b5df215f that allows you to specify the target model for a column-like. So your example:\r\n\r\n```python\r\ndef show_attached(uid):\r\n sub_cte = Subscription.select().where(Subscription.user == uid).cte('sub_cte')\r\n sel = (AttachedFile.id,\r\n AttachedFile.file_name,\r\n Case(fn.EXISTS(sub_cte.select()),\r\n [(False, None)],\r\n AttachedFile.file_url).alias('file_url').bind_to(AttachedFile)) # Note the .bind_to() here.\r\n q = (Article\r\n .select(*sel)\r\n .join_from(Article, AttachedFile)\r\n .with_cte(sub_cte))\r\n return q\r\n\r\n# Note the file_url is now on attached_file!\r\nfor row in show_attached(u2.id):\r\n print(row.attached_file.file_name, row.attached_file.file_url)\r\n\r\n# For user-3 there is a subscription, so file url is shown:\r\nfor row in show_attached(u3.id):\r\n print(row.attached_file.file_name, row.attached_file.file_url)\r\n```", "@coleifer That's what I need, but shouldn't it just be like:\r\n\r\n```python3 \r\nCase(...).alias(AttachedFile.file_url) # conditional `file_url`\r\n# and \r\nValue('https://...').alias(AttachedFile.file_url) # replace the value of `file_url`\r\n# and\r\n(AttachedFile.file_size / 1000).alias(AttachedFile.file_size) # convert KB to MB\r\n```\r\nit just looks more compact and dynamic. I think it doesn't break anything, right?", "`to_bind` would be extra here as `AttachedFile` already tells Peewee the model we want to bind.\r\n\r\nAnd also we will be able to pass model columns into the `alias` method:\r\n```python3\r\nArticle.select(Value('it is a value').alias(Article.title))\r\n```\r\ninstead of \"hard coding\" the column names:\r\n```python3\r\nArticle.select(Value('it is a value').alias('title'))\r\n```\r\nor it can be used like this (It looks a bit strange, but it's very useful in some cases):\r\n```python3\r\nArticle.select(AttachedFile.file_name.alias(Article.title))\r\n```", "Let me think about it for a bit this morning.", "So the benefit of using `.bind_to()` is that you can specify the destination model in a multi-model query *regardless* of whether the alias corresponds to a field. For example, from the tests:\r\n\r\nhttps://github.com/coleifer/peewee/commit/eeff376be5af089e7d3849284a1c1d71b5df215f#diff-969c0712020e8472d8d78ae32190692cc1e8a3e16dc17f6977c8f87a1328adb7R4896-R4904\r\n\r\nIn the above, we alias a Case expression to a name that does not correspond to a field, and also specify that it should be applied on the related `User` instance.\r\n\r\nIf `Alias()` is extended to support a field/column as the destination, then we lose this functionality.\r\n\r\nI think I'm going to leave it as-is for now, even though it is more verbose in your particular examples." ]

[]

[]

[ "```\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = db\r\n```", "Please post on StackOverflow in the future. Questions like this are not appropriate to the issue tracker.\r\n\r\nDocs: http://docs.peewee-orm.com/en/latest/peewee/query_operators.html#sql-functions\r\n\r\nYour specific error is because your `Review.__str__` method, which you're calling when you iterate over your query results and print them, does a database lookup. Since you did not select the related column (`review_status_type`) we weren't able to look up the status and hence could not print. The error even states ReviewStatusTypeDoesNotExist...\r\n\r\nHere's the copy/paste answer you probably are looking for:\r\n\r\n```python\r\ndescription = 'NAN63831511'\r\n\r\n# Single value.\r\nmax_ver = (Review\r\n .select(fn.Max(Review.version))\r\n .where(Review.description == description)\r\n .scalar())\r\n```", "Thank you, much appreciated." ]

[]

[]

[ "#630 \r\n\r\nhttps://gist.github.com/b1naryth1ef/607e92dc8c1748a06b5d", "Thanks for your response . I have seen this method . This is also not working." ]

[]

[]

[ "Presumably you would know something about the database that's executing the queries, right? Or is this library restricted to operating on queries in absence of any other context? The `_database` attr is fine to use, I don't anticipate it changing any time soon.", "@coleifer \r\n\r\nI'm writing a library that is to be used by other applications. The library doesn't know what database the user will use.\r\n\r\nI need different behavior for postgres vs mysql. This function will return the updated result set if it is in postgres, or it will query the updated table and return the result if it is mysql.\r\n\r\nI can use the `_database` attribute, but I suppose I would rather not rely on a private attribute if possible.\r\n\r\nA Database Proxy cannot be used for this case, could it?", "Check out this example from the `playhouse` on how I've differentiated functionality by db: https://github.com/coleifer/peewee/blob/master/playhouse/kv.py#L16-L56\r\n\r\nI would recommend using `_database` and then looking up the corresponding property, e.g. `if query._database.returning_clause:`. Common properties are listed in the `class Database(...):` in peewee.py." ]

[]

[]

[ "You can add a constraint to the table in the following manner:\r\n\r\n```python\r\nclass Post(Model):\r\n author = TextField()\r\n title = TextField()\r\n class Meta:\r\n database = db\r\n primary_key = CompositeKey('author', 'title')\r\n\r\nclass Comment(Model):\r\n post_author = TextField()\r\n post_title = TextField()\r\n comment = TextField()\r\n class Meta:\r\n constraints = [\r\n SQL('foreign key (post_author, post_title) references post(author, title)'),\r\n ]\r\n database = db\r\n depends_on = [Post] # Since no explicit FK field, this ensures tables created in proper order.\r\n\r\ndb.create_tables([Post, Comment])\r\n\r\np1 = Post.create(author='a1', title='t1')\r\np2 = Post.create(author='a2', title='t2')\r\nComment.create(post_author=p1.author, post_title=p1.title, comment='p1-c')\r\nComment.create(post_author=p2.author, post_title=p2.title, comment='p2-c')\r\nwith db.atomic():\r\n try:\r\n Comment.create(post_author='a1', post_title='tx', comment='p1-x')\r\n except IntegrityError:\r\n print('received expected integrity error.')\r\nwith db.atomic():\r\n try:\r\n Comment.create(post_author='ax', post_title='t1', comment='p1-x')\r\n except IntegrityError:\r\n print('received expected integrity error.')\r\n\r\ndb.drop_tables([Post, Comment])\r\n```\r\n\r\nSee the table of supported Model metadata options:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#model-options-and-table-metadata" ]

[]

[]

[ "I'll see about rewording this later. The docs are trying to show what the available options are, and their default values." ]

[]

[]

[ "You can use the helper in `playhouse.mysql_ext`:\r\n\r\n```python\r\nfrom playhouse.mysql_ext import Match\r\n\r\nmatch = Match((Script.title, Script.description), 'some word', 'with query expansion')\r\nScript.select(Script, match.alias('score'))\r\n```\r\n\r\nAlternatively, if you want to just build the expression manually, you can write a helper function to make this less tedious:\r\n\r\n```python\r\nfrom peewee import *\r\nfrom peewee import NodeList # Not exported by default\r\n\r\nclass Note(Model):\r\n title = TextField()\r\n body = TextField()\r\n\r\ndef match(word):\r\n match = fn.MATCH(Note.title, Note.body)\r\n against = fn.AGAINST(NodeList(('word', SQL('with query expansion'))))\r\n return NodeList((match, against))\r\n\r\n# in select\r\nNote.select(Note, match('some word').alias('score'))\r\n\r\n# in where\r\nNote.select().where(match('some other words'))\r\n```", "http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#mysql-extensions" ]

[]

[]

[ "You need to understand how Peewee manages connections -- peewee creates a connection-per-thread and will not automatically reconnect if that connection should get closed by the server. Why? What if you were in the middle of a transaction or had uncommitted changes -- we don't want to silently lose those.\r\n\r\nSo what you need to do is ensure you are opening and closing your connections properly. Here's an example:\r\n\r\n```python\r\n\r\ndb = PostgresqlExtDatabase(...)\r\n\r\ndef long_running_task():\r\n while True:\r\n db.connect()\r\n # do some work with the database\r\n db.close()\r\n\r\n # wait for more work to do.\r\n```\r\n\r\nMy suggestions are: \r\n\r\n* open the connection for the short periods of time when you actually need it, close when done\r\n* use a connection pool with the above if the overhead of opening/closing connections is an issue" ]

[]

[]

[]

[]

[]

[ "0f1a49202b72b18074032efa56e42d4aeef95cce" ]

[]

[]

[ "It seems you have not read this part of the documentation: http://docs.peewee-orm.com/en/latest/peewee/models.html#default-field-values\r\n\r\n> Remember: when using the default parameter, the values are set by Peewee rather than being a part of the actual table and column definition.", "Huh, a peculiar design choice.\r\n\r\nIs there a way to propagate the default value to the table then?", ">Link him the docs.\r\n>\r\n>Still doesn't read it.\r\n\r\n@SandaruKasa ... come on.\r\n\r\n>The database can also provide the default value for a field. While peewee does not explicitly provide an API for setting a server-side default value, you can use the constraints parameter to specify the server default:\r\n>\r\n>```\r\n>class Message(Model):\r\n> context = TextField()\r\n> timestamp = DateTimeField(constraints=[SQL('DEFAULT CURRENT_TIMESTAMP')])\r\n>```\r\n" ]

[]

[]

[ "Yes, this was fixed here: 4741e9f07d2f0fccee3a4731bc03093ef56e26f5\r\n\r\nThe regression is due to a change in the way Sqlite 3.39.0 propagates subtypes from columns in subqueries. \r\n\r\n* https://sqlite.org/src/info/\r\n* https://sqlite.org/forum/forumpost/9c94b6188e", "Is it possible to skip that single test with `runtests.py`, or would you suggest for us to wait for a new version?", "I pushed a new release, 3.15.1, which contains the patch.", "Thank you very much Charles!" ]

[]

[]

[ "Thanks!" ]

[]

[]

[ "Since it passed this part of code as `False`\r\n```python\r\ndef cursor(self, commit=None):\r\n if self.is_closed():\r\n if self.autoconnect:\r\n self.connect()\r\n else:\r\n raise InterfaceError('Error, database connection not opened.')\r\n ...\r\n```\r\n\r\nIt seems that `self.is_closed()` returns wrong value", "Can you provide a short reproduction of the issue?", "The reproduction can't be short, cause I'm using Docker Swarm and it seems to be killing idle connections between nodes. At least I can't explain these connectivity issues any other way.\r\n\r\nBut anyway peewee should reconnect properly in this situation.\r\n", ">It seems that self.is_closed() returns wrong value\r\n\r\n`is_closed()` refers to the presence or absence of a connection -- but does not indicate the health of that connection.\r\n\r\n>and it seems to be killing idle connections between nodes\r\n\r\nIf this is, in fact, what is happening, then you probably want to review your use of connections -- especially the pool (which implies potential long-idle connections if you have low traffic to the db).\r\n\r\nDo you have a way to reliably detect when a connection has been closed? Check the code for `playhouse.pool._PooledPostgresqlDatabase._is_closed()`. When a connection is checked-out from the connection pool, the pool will use the above to test whether the connection is live and usable. This means that if you are checking out a connection from the pool (by using `db.connect()`), Peewee checks to see if that connection can be used before returning it to you. So you may want to review your connection management, specifically when you check-out and return conns to the pool.\r\n\r\nIf the above check is *not* detecting the \"connection already closed\" error, however (though this seems very unlikely to me) you can try subclassing and extending the `PooledPostgresqlExtDatabase` with a better check.\r\n\r\nMy sense, however, is that you're probably checking out connections and then letting them sit idle for a long time without returning them to the pool. Thus they never receive the health checks.\r\n\r\nLastly, Peewee does not automatically reconnect upon receiving this InterfaceError.", "Oh, you can also use `db.is_connection_usable()`, which has db-specific implementations for checking whether the underlying connection is in good shape.", "It's not clear. Just read the texts\r\n\r\nFirst you're checking `is_closed` and receive False. It means NOT CLOSED.\r\nThen you're trying to execute statement and receive `connection already closed`. It means it CLOSED.\r\n\r\nIf the connection is unusable, why don't you check `db.is_connection_usable()` with autoconnect option? \r\n\r\n```python\r\ndef cursor(self, commit=None):\r\n if self.is_connection_usable():\r\n if self.autoconnect:\r\n self.connect()\r\n else:\r\n raise InterfaceError('Error, database connection not opened.')\r\n ...\r\n```", "`is_closed()` refers to the internal state of Peewee -- whether we have a connection or not. I get that it's confusing, but we also don't want to just blindly autoconnect in the event that the connection is killed at some random time -- what if you were in the middle of a transaction, or had uncommitted changes?\r\n\r\nSimilarly, `autoconnect` does not refer to automatically reconnecting in the event of some error -- rather it means that you don't have to explicitly call `connect()` when you want to start querying the database.\r\n\r\nWe don't check whether the connection is usable because that would add overhead to every single query executed by Peewee. Internally Peewee gets a cursor for each query it executes. The approach taken by peewee is to open the connection and keep it until `close()` is called. This is slightly different for the pool -- the pool will obviously retain connections and check whether they are usable only when they are initially checked-out.\r\n\r\nAs I stated earlier, I suggest checking up on your use of connections." ]

[]

[]

[ "http://docs.peewee-orm.com/en/latest/peewee/database.html#adding-a-new-database-driver\r\n\r\nLooks like there's a driver with dbapi support so hopefully it will be rather easy.\r\n\r\nhttps://docs.snowflake.com/en/user-guide/python-connector.html" ]

[]

[]

[ "Facetting is typically done on the set of search results anyways, so this seems like an application for `in_`, may it be a matching regex or some attribute value that is more commonly used for facetting.\r\n\r\nI haven't looked at it in detail but I guess sqlite_ext does a phrase search (and won't tokenize my input and just assume some operator) and thus I have to query it per-term (which is a good thing) and combine the results. But all of that is out of peewee's scope. The point is that I'll have to combine/process the search results anyways if I want a query language with operators.", "You don't need to re-select, just write: \r\n\r\n```\r\nquery = (ItemIndex\r\n .search_bm25(search_query, with_score=True)\r\n .where(ItemIndex.content.regexp(search_regex)))\r\n```\r\n\r\nAlso, Peewee provides a `regexp_function` already and the parameter is a boolean - not a callable.\r\n\r\nExample:\r\n\r\n```python\r\ndb = SqliteExtDatabase(':memory:', regexp_function=True)\r\n\r\nclass Idx(FTS5Model):\r\n name = SearchField(unindexed=True)\r\n content = SearchField()\r\n class Meta:\r\n database = db\r\n\r\ndb.create_tables([Idx])\r\n\r\nIdx.insert_many([\r\n ('item1', 'item1 alpha'),\r\n ('item2', 'item2 beta'),\r\n ('item1-1', 'item1-1 alpha epsilon'),\r\n ('item1-2', 'item1-2 alpha sigma'),\r\n ('item1-3', 'item1-3 alpha rho'),\r\n ('item1-4', 'item1-4 alpha tau'),\r\n]).execute()\r\n\r\n\r\nquery = (Idx\r\n .search_bm25('alpha', with_score=True)\r\n .where(Idx.content.regexp('item1-[123]')))\r\nfor row in query:\r\n print(row.name, row.content)\r\n\r\n# item1-1 item1-1 alpha epsilon\r\n# item1-2 item1-2 alpha sigma\r\n# item1-3 item1-3 alpha rho\r\n```", "Yes, this is clear to me now because i read more docs. Thanks for the examples and your help! Appreciate it!" ]

[]

[]

[ "When you write:\r\n\r\n`return selection or model.select()`\r\n\r\nPython needs to determine if `selection` is truth-y, so it calls its `__len__()` method to see if it's empty. This causes the query to be evaluated. The better way to do this is:\r\n\r\n`return selection if selection is not None else model.select()`" ]

[]

[]

[ "Thanks, I merged a roughly equivalent patch." ]

[]

[]

[ "This is now resolve, thanks for the report. In the meantime you can alternatively use the database itself as a context-manager, which ensures a connection is created and wraps the block in a transaction (assuming this is for module-scope type initialization or whatever), e.g.\r\n\r\n```python\r\nwith db:\r\n ...\r\n```" ]

[]

[]

[ "Your error handling code looks good to me. I cannot think of what might be causing this, as it seems to be working fine on my side:\r\n\r\n\r\n\r\nIt also works when swapping `PooledPostgresDatabase`.", "moving **txn.rollback()** to the first line under the **execpt:** fixed it for me.\r\n```\r\ntry:\r\n pass\r\nexcept Exception as exc:\r\n txn.rollback()\r\n e = traceback.format_exc()\r\n print(f\"<p>Error: {exc}</p>{e}\")\r\n query_failed = True\r\n```" ]

[]

[]

[ "I have no idea what these screenshots are supposed to show. Post a self-contained, self-explanatory code snippet.", "Possibly this is to do with floating point precision. You need to use numeric / decimal field for prices.", "Confirmed this is floating point stuff.\r\n\r\n```\r\nIn [1]: from peewee import *\r\n\r\nIn [2]: db = PostgresqlDatabase('peewee_test')\r\n\r\nIn [3]: class K(Model):\r\n ...: price = FloatField()\r\n ...: name = TextField()\r\n ...: class Meta:\r\n ...: database = db\r\n ...: \r\n\r\nIn [4]: db.create_tables([K])\r\n\r\nIn [5]: K.create(price=123.45, name='12345')\r\nOut[5]: <K: 1>\r\n\r\nIn [6]: K.create(price=123.44, name='12344')\r\nOut[6]: <K: 2>\r\n\r\nIn [7]: K.create(price=123.46, name='12346')\r\nOut[7]: <K: 3>\r\n\r\nIn [8]: K.select().where(K.price < 123.45).tuples()[:]\r\nOut[8]: [(1, 123.45, '12345'), (2, 123.44, '12344')]\r\n\r\nIn [9]: K.select().where(K.price >= 123.45).tuples()[:]\r\nOut[9]: [(3, 123.46, '12346')]\r\n```\r\n\r\nNext time submit code like ^^", "> \r\n\r\nThanks a lot! I changed my FloatFields to DecimalFields and I can confirm that this remedied my issue. \r\n\r\nMy sincerest apologies for the lazy issue. I'll make sure to post self-contained, self-explanatory code snippets next time." ]

[]

[]

[ "This is because Peewee wraps any query that executes a `.count()`, so the actual sql that peewee ends up executing looks like:\r\n\r\n```sql\r\n-- Post.select(Post.author_id).distinct().count()\r\nSELECT COUNT(1) FROM (\r\n SELECT DISTINCT \"t1\".\"user_id\" FROM \"tweet\" AS \"t1\"\r\n) AS \"_wrapped\"\r\n```\r\n\r\nThe second example, however, Peewee does not infer that there is important information it is supposed to capture inside the selected columns, and so we end up with:\r\n\r\n```sql\r\n-- Post.select(Post.author_id.distinct()).count()\r\nSELECT COUNT(1) FROM (SELECT 1 FROM \"tweet\" AS \"t1\") AS \"_wrapped\"\r\n```\r\n\r\nSo what you should do is either:\r\n\r\n* `Post.select(Post.author_id).distinct().count()`\r\n* `Post.select(fn.COUNT(Post.author_id.distinct())).scalar()`" ]

[]

[]

[ "I don't see anything in the python 3.11 changelog that looks promising, any ideas?", "I'm going to try bisecting it.", "And here it is:\r\n\r\nhttps://github.com/python/cpython/commit/3df0fc89bc2714f5ef03e36a926bc795dcd5e05a\r\n\r\n```\r\ncommit 3df0fc89bc2714f5ef03e36a926bc795dcd5e05a\r\nAuthor: Erlend Egeberg Aasland <[email protected]>\r\nDate: Wed Aug 25 12:28:47 2021 +0200\r\n\r\n bpo-44976: Lazy creation of sqlite3 result rows (GH-27884)\r\n\r\n Modules/_sqlite/cursor.c | 84 +++++++++++++++++-------------------------------\r\n Modules/_sqlite/cursor.h | 3 --\r\n 2 files changed, 29 insertions(+), 58 deletions(-)\r\n```", "Thanks @mgorny very nice! My sense is that this may be a bug in `sqlite3` (cc @erlend-aasland if you see this).", "Can you report this on the CPython bug tracker? Please include a minimal (bare-bones) reproducer and as much information about your environment as possible.\r\n\r\nThanks!", "Sure I'll report and send a test if it's indeed a cpython issue. My sense is that it is but I'll let you know early next week ", "Great, thanks.\r\n\r\nFYI, beta 4 is over-due, but is currently on hold bco. release blockers. I've notified the RM about this (possible) issue; if we could pin-point a minimal reproducer pretty quick, we could add this to the beta 4 release blockers, so we'd get a fix in the upcoming (b4) release.\r\n\r\nI've tried to create a repro, but it's a little bit hard, since I've never used peewee, and I don't know its internal workings :( ", "No worries, I'll take a look tomorrow (Mon) morning and let you know asap. Thx!", "Welp, I have managed to reproduce and think it has something to do with cursor garbage collection. Something quite strange is going on that I haven't so far experienced in all the time I've used Python. Here's what I've observed with peewee:\r\n\r\n* Peewee test fails when run by itself\r\n* If I insert a breakpoint right before line 461 and then \"continue\", the test is passing(?)\r\n* If I insert a breakpoint right before line 461 and then \"next\", the test fails(?)\r\n* If I insert a time.sleep(1) right before line 461, the test fails\r\n\r\nExample of breakpoint + continue -> passing:\r\n\r\n```\r\n> /home/charles/tmp/py311/src/peewee/tests/db_tests.py(461)test_sqlite_isolation()\r\n-> curs = new_db.execute_sql('SELECT COUNT(*) FROM users')\r\n(Pdb) c\r\n.\r\n----------------------------------------------------------------------\r\nRan 1 test in 1.122s\r\n```\r\n\r\nExample of breakpoint + next -> fails again:\r\n\r\n```\r\n> /home/charles/tmp/py311/src/peewee/tests/db_tests.py(461)test_sqlite_isolation()\r\n-> curs = new_db.execute_sql('SELECT COUNT(*) FROM users')\r\n(Pdb) n\r\n> /home/charles/tmp/py311/src/peewee/tests/db_tests.py(462)test_sqlite_isolation()\r\n-> self.assertEqual(curs.fetchone()[0], 0)\r\n(Pdb) n\r\nTypeError: 'NoneType' object is not subscriptable\r\n```\r\n\r\nI cannot understand why it is passing when there's a breakpoint and then I select \"continue\" but using \"next\" makes it fail again!\r\n\r\n-------------------------------------------------------------------\r\n\r\n### Repro with stdlib sqlite3\r\n\r\nHere is my repro. It took a while to get it to reproduce, but I had a feeling it had something to do (possibly) with garbage collection or cursors. Keeping the cursors around in memory seems to cause the problem to manifest, but if you comment-out the line indicated below then the tests will pass. Note that Peewee doesn't do anything weird like keep the cursors in memory, this was just the first way I've been able to successfully reproduce the issue. @erlend-aasland \r\n\r\n```\r\nimport glob\r\nimport os\r\nimport sqlite3\r\n\r\nfilename = '/tmp/test.db'\r\nfor f in glob.glob(filename + '*'):\r\n os.unlink(f) # Cleanup anything from prev run(s).\r\n\r\nCURSORS = {}\r\n\r\ndef sql(conn, sql, *params):\r\n curs = conn.cursor()\r\n curs.execute(sql, params)\r\n CURSORS[id(sql)] = curs # COMMENT THIS OUT AND TEST WILL PASS.\r\n return curs\r\n\r\n# Set up database w/some sample rows. Peewee sets isolation-level to None as we\r\n# want to manage all transaction state ourselves, rather than use sqlite3's\r\n# somewhat unusual semantics.\r\ndb = sqlite3.connect(filename, isolation_level=None)\r\ndb.execute('create table users (id integer not null primary key, '\r\n 'username text not null)')\r\nsql(db, 'insert into users (username) values (?), (?), (?)', 'u1', 'u2', 'u3')\r\ndb.commit()\r\n\r\n# On 2nd connection verify rows are visible, then delete them.\r\nnew_db2 = sqlite3.connect(filename, isolation_level=None)\r\nassert sql(new_db2, 'select count(*) from users').fetchone()[0] == 3\r\nassert sql(new_db2, 'delete from users').rowcount == 3\r\n\r\n# Back in original connection, create 2 new users.\r\nsql(db, 'begin')\r\nsql(db, 'insert into users (username) values (?)', 'u4')\r\nsql(db, 'insert into users (username) values (?)', 'u5')\r\n\r\n# 2nd connection cannot see uncommitted changes.\r\n# NOTE: this is the line that fails.\r\nassert sql(new_db2, 'select count(*) from users').fetchone()[0] == 0\r\n\r\n# Original conn can see its own changes.\r\nassert sql(db, 'select count(*) from users').fetchone()[0] == 2\r\ndb.commit()\r\n\r\n# Now the 2nd conn can see the changes.\r\nassert sql(new_db2, 'select count(*) from users').fetchone()[0] == 2\r\n```\r\n\r\nLastly, just as a sanity-check, the above script runs without error on Python 2.7, 3.6, 3.9 and 3.10 -- it only fails on 3.11.0b3.", "@erlend-aasland - I've created a new ticket on the CPython issue tracker, linked above python/cpython#94028 . As I mentioned on the cpython issue, this really is bizarre:\r\n\r\n>What is doubly-confusing about this error is that, when the failure occurs, the SQL being executed should definitely NOT be returning `None` from the call to `fetchone()`. If the table did not exist, we would get a different error from Sqlite. If the table does exist and we just can't see any rows, then we should be getting `0` (or possibly `2`) as the test asserts. Instead, the `fetchone()` is returning `None`.", "Since this seems to me quite definitively a CPython / sqlite3 issue, I will close here.", "Thanks a lot for your investigations, @coleifer! I've marked python/cpython#94028 as a release blocker. Hopefully we'll find a solution within the next few days.", "I have a fix for this in python/cpython#94042. If you have the possibility to test the fix before I merge it, I'd appreciate it, @mgorny.", "I can confirm that applying this patch to cpython causes peewee tests to pass.", "(I've applied it on top of 3.11.0b3)", "Great, thank you!", "Thank you both @mgorny and @erlend-aasland for the help finding and fixing this.", "FYI, the fix has been merged and will appear in the upcoming beta 4 release." ]

[]

[]

[ "This is fundamental to how relational databases operate, I'm not sure what to tell you, it's not magic. The docs describe some approaches, however, which you may check out: http://docs.peewee-orm.com/en/latest/peewee/relationships.html#avoiding-the-n-1-problem" ]

[]

[]

[ "I can't replicate the exception -- I agree that it looks like there may be a bug there, but I'm not sure how to trigger it. The following all work just fine:\r\n\r\n```python\r\nclass TestDjangoFilterRegression(ModelTestCase):\r\n requires = [User, Tweet]\r\n\r\n def test_django_filter_regression(self):\r\n a, b, c = [User.create(username=u) for u in 'abc']\r\n Tweet.create(user=a, content='a1')\r\n Tweet.create(user=a, content='a2')\r\n Tweet.create(user=b, content='b1')\r\n\r\n query = User.filter(username='a')\r\n self.assertEqual(sorted([u.username for u in query]), ['a'])\r\n\r\n query = User.filter(username__in=('a', 'c', 'x'))\r\n self.assertEqual(sorted([u.username for u in query]), ['a', 'c'])\r\n\r\n query = Tweet.filter(user__username='a')\r\n self.assertEqual(sorted([t.content for t in query]), ['a1', 'a2'])\r\n\r\n query = Tweet.filter(user__username__in=('a', 'c'))\r\n self.assertEqual(sorted([t.content for t in query]), ['a1', 'a2'])\r\n```", "I think you need to have 3 level relations like this\r\n\r\n```\r\nclass Hour(Model):\r\n project = ForeignKeyField(Project, backref=\"hours\")\r\n\r\nclass Project(Model):\r\n client = ForeignKeyField(Client, backref=\"projects\")\r\n\r\nclass Client(Model):\r\n```\r\n\r\nWhen i want to filter all the hours (of all projects) for a specific client, i can filter the hours with a Django criteria 'project__client=1' in previous version without error. The criteria is coming from the URL for a backend call\r\n\r\nI hope this will help you\r\n\r\n N.B I do my best to write in english, i'm a french speaker. Sorry if is not sound good ! \r\n\r\n\r\n\r\n\r\n", "I'm still unable to replicate the issue: https://github.com/coleifer/peewee/blob/master/tests/regressions.py#L1705-L1710 -- this is traversing 2 relationships. That unit test covers quite a few scenarios.\r\n\r\nIf you can produce a failing test in the above case, or write a new one that demonstrates the issue, I will gladly reopen.", "Could you give me some advise how to set the project to run tests. I'll take a look and try to reproduce the error. Thanks !", "A git checkout and executing «runtest.py regressions» seem to do the job. I will print a comment in every step to check if your regressions tests invoke every possible situation of convert_dict_to_node. Does it seem a good idea ?", "Presumably if you are able to replicate the exception locally with your own code, you can communicate to me what is different about it vs the tests, or how to modify the tests to replicate it...", "Finally figured it out, will post a fix shortly.", "Glad you found it ! You're right on. My query is using already joined relations too. Thanks for your help and the incoming release" ]

[]

[]

[ "This is a relatively recent addition:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/api.html#Insert.as_rowcount\r\n\r\n```python\r\niq = User.insert_many([(u,) for u in ('u1', 'u2', 'u3')])\r\niq = iq.returning()\r\nassert iq.as_rowcount().execute() == 3\r\n```", "I tried it, but not work, I am using postgress and peewee 3.14.10\r\n\r\n\r\n", ">This is a relatively recent addition:" ]

[]

[]

[ "Wrong. It's correct." ]

[]

[]

[ "found the reason", "\r\nI made a mistake" ]

[]

[]

[ "That's alright, we test using MariaDB." ]

[]

[]

[ "Probably the easiest way is to override the `save()` method:\r\n\r\n```python\r\nclass BaseModel(...):\r\n def save(self, *args, **kwargs):\r\n self.updated_at = dt.now(tz)\r\n if not self.created_at: self.created_at = self.updated_at\r\n return super(BaseModel, self).save(*args, **kwargs)\r\n```", "Thanks!\r\nApparently, this won't work when using `Model.insert()`, since it would require a database-level default (`DEFAULT CURRENT_TIMESTAMP`).\r\nBut in order to have a database-level default, we would need to get rid of the Peewee default value, which then would break the logic for `Model.create()`.", ">which then would break the logic for Model.create().\r\n\r\nThat doesn't sound correct to me.", "You are right, sorry!\r\nI think what broke my tests was that `db.evolve()` won't detect the new `constraints=[SQL('DEFAULT CURRENT_TIMESTAMP')]` param.\r\nIs it expected? I just checked [the docs](https://docs.peewee-orm.com/en/latest/peewee/models.html?highlight=CURRENT_TIMESTAMP#some-fields-take-special-parameters) but didn't find anything stating it wouldn't be detected by `db.evolve()`.", "I don't know what evolve is. It's not part of this library. Database-provided defaults work just fine with peewee, as do python-side defaults.", "Sorry @coleifer, I thought peewee db evolve was part of this library. Thanks very much for your help!" ]

[]

[]

[ "Try this:\r\n\r\n```python\r\nclass CryptoTransaction(peewee.Model):\r\n currency = peewee.CharField(default=\"usdt\", index=True, max_length=255)\r\n hash = peewee.CharField(unique=True)\r\n\r\n class Meta:\r\n db_table = \"crypto_transaction\"\r\n database = peewee.SqliteDatabase(':memory:')\r\n legacy_table_names = False\r\n```\r\n\r\nThis gives the following output:\r\n\r\n```\r\ncrypto_transaction\r\ncrypto_transaction_hash\r\n['crypto_transaction_currency', 'crypto_transaction_hash']\r\n```\r\n\r\n`make_index_name` doesn't know about model classes or whether they use old or new-style table names, so it just uses the table name itself. I cannot change the default index-name generation without breaking compatibility.\r\n```" ]

[]

[]

[ "Yes, aliases must be used when you want to have Python identifiers or dict keys. Peewee tries to determine the column name to use based on whatever the cursor indicates, but when you have an expression (like `SUM(\"t1\".\"value\") OVER \"w\"`) then Peewee's column-name code can't really figure out what to call it." ]

[]

[]

[]

[]

[]

[ "You're extending peewee.ModelBase for some reason: `class baseModel(peewee.ModelBase):`\r\n\r\nChange that to `class baseModel(peewee.Model)` and you'll be set.", "It now gives me a slightly different error\r\n```\r\nAttributeError: 'NoneType' object has no attribute '_meta'\r\n```", "Found the issue, i had the manytomany fields model=None" ]

[]

[]

[ "Okay, so when I query the object directly with `select()`, it does indeed show as being updated.\r\n\r\nHowever, when accessing the object through a relationship that existed prior to the update(), the update() is not reflected. That is what was throwing me off.\r\n\r\n---\r\n\r\nThere is only 1 Label\r\n```python\r\n>>> list(orm.Label.select())\r\n[<Label: 1>]\r\n```\r\n\r\n```python\r\n>>> tf_bin_tab = some query\r\n>>> tf_bin_tab.some_operation_that_updates_label()\r\n\r\n>>> tf_bin_tab.splitset.label.__dict__ #<-- why isn't traversing the rels running a new query?\r\n{'__data__': {'id': 1,\r\n 'time_created': '2022-05-27 13:02:48.587761-04:00',\r\n 'time_updated': '2022-05-27 13:02:48.587782-04:00', #<--- unchanged, why?\r\n 'name': None,\r\n 'version': None,\r\n 'description': None,\r\n 'columns': ['object'],\r\n 'column_count': 1,\r\n 'unique_classes': ['R', 'M'],\r\n 'fitted_labelcoder': None, #<--- unchanged, why?\r\n 'dataset': 1},\r\n '_dirty': set(),\r\n '__rel__': {}}\r\n[0]\r\n```\r\n\r\nAccessing it via a fresh query\r\n```python\r\n>>> tf_bin_tab = some query\r\n>>> tf_bin_tab.some_operation_that_updates_label()\r\n\r\n>>> orm.Label.select()[0].__dict__\r\n{'__data__': {'id': 1,\r\n 'time_created': '2022-05-27 13:02:48.587761-04:00',\r\n 'time_updated': '2022-05-27 13:02:48.889901-04:00', #<--- changed, as expected\r\n 'name': None,\r\n 'version': None,\r\n 'description': None,\r\n 'columns': ['object'],\r\n 'column_count': 1,\r\n 'unique_classes': ['R', 'M'],\r\n 'fitted_labelcoder': [LabelBinarizer()], #<--- changed, as expected\r\n 'dataset': 1},\r\n '_dirty': set(),\r\n '__rel__': {}}\r\n```", "Okay, and if I do a fresh query of the related object, and access it - then it too bears the updates\r\n\r\n```python\r\norm.Splitset.select()[0].label.__dict__\r\n{'__data__': {'id': 1,\r\n 'time_created': '2022-05-27 13:02:48.587761-04:00',\r\n 'time_updated': '2022-05-27 13:02:48.889901-04:00', #<--- changed, as expected\r\n 'name': None,\r\n 'version': None,\r\n 'description': None,\r\n 'columns': ['object'],\r\n 'column_count': 1,\r\n 'unique_classes': ['R', 'M'],\r\n 'fitted_labelcoder': [LabelBinarizer()], #<--- changed, as expected\r\n 'dataset': 1},\r\n '_dirty': set(),\r\n '__rel__': {}}\r\n```\r\n\r\nSo it looks like the querysets are stale in that they don't reflect the update. Is this to be expected?", "Seems like the crux of the question is this:\r\n\r\n```python\r\n>>> tf_bin_tab.splitset.label.__dict__ #<-- why isn't traversing the rels running a new query?\r\n```\r\n\r\nIf you access the related object, Peewee caches the instance in-memory so that future accesses do not repeat the query. If you update the object somewhere else (e.g. not the in-memory instance) then the cached one will not show the update. Peewee is an active record orm so this is expected.\r\n\r\nExample:\r\n\r\n```python\r\ndb = SqliteDatabase(':memory:')\r\n\r\nclass Base(Model):\r\n class Meta: database = db\r\n\r\nclass User(Base):\r\n username = TextField()\r\n\r\nclass Tweet(Base):\r\n user = ForeignKeyField(User)\r\n content = TextField()\r\n\r\ndb.create_tables([User, Tweet])\r\n\r\nu = User.create(username='u')\r\nTweet.create(user=u, content='t1')\r\n\r\n# Demonstrate the way related objects work:\r\nt = Tweet.get()\r\nt.user.username = 'ux'\r\nt.user.save()\r\n\r\nassert u.username == 'u'\r\n\r\nu = User.get()\r\nassert u.username == 'ux'\r\n```" ]

[]

[]

[ "http://docs.peewee-orm.com/en/latest/peewee/models.html#model-options-and-table-metadata\r\n\r\n```\r\nclass BaseModel(Model):\r\n class Meta:\r\n schema = 'myschema'\r\n```" ]

[]

[]

[]

[]

[]

[ "Sorry, I installed psycopg not psycopg2. Please excuse me!", "You probably want to use `psycopg2` or `psycopg2-binary` as those are better supported by Peewee and can coexist alongside your install of `psycopg==3`." ]

[]

[]

[ "SOLVED!\r\n\r\nI solved the problem. Nothing was wrong with the code. Just needed to remigrate my database. For those experiencing similar problem, script below tends to work:\r\n```\r\ndb.connect()\r\n\r\nmodels = [\r\n User\r\n]\r\n\r\ndb.drop_tables(models)\r\n\r\ndb.create_tables(models)\r\n```\r\n`db` is an instance of peewee database initialization." ]

[]

[]

[ "Thanks, this was an accidental omission, and is now resolved." ]

[]

[]

[ "You can add an index via `sqlite3 mydb-file` and adding it there. The sqlite docs have plenty of info on creating indexes. To do it via peewee you can:\r\n\r\n* Main doc http://docs.peewee-orm.com/en/latest/peewee/models.html#indexes-and-constraints\r\n* add it to the field definition, e.g. `my_field = IntegerField(index=True)`\r\n* add it to the model class' Meta.indexes \r\n* use [modelindex apis](http://docs.peewee-orm.com/en/latest/peewee/api.html#ModelIndex)\r\n* use `db.execute_sql()` directly to create the index\r\n\r\nYou can call `ModelClass._schema.create_indexes(safe=True)` after adding the index.\r\n\r\nBut for what you're trying to do specifically, a bloom filter is probably a better option.", "If I understand you correctly:\r\n\r\nRetrieve all rows from first_table that exist in the second_table, based on a shared value in common_column:\r\n```\r\nselect * from first_table\r\nwhere exists (\r\n select 1\r\n from second_table\r\n where first_table.common_column = second_table.common_column\r\n)\r\n```\r\n\r\nIn peewee:\r\n\r\n FirstTable.select().where(\r\n fn.exists(second_table.select().where(\r\n FirstTable.common_column == SecondTable.common_column\r\n ))\r\n )\r\n\r\nYou can change this to `not exists` to retrieve all rows from first_table that are missing in second_table. In peewee that would be `~fn.exists`" ]

[]

[]

[ "It's not `fn.filter()` -- you want `fn.COUNT(EventModel.id).filter(EventModel.status == 'cancelled')`\r\n\r\nThis is not a peewee issue, but rather an issue in incorrectly translating SQL to peewee APIs.", "That's exactly what I have... except it's BookingModel, not EventModel. It doesn't work. Apologies for the title being slightly off. Updated.\r\n\r\n@coleifer ", "To clarify:\r\n\r\n```python\r\npeewee.fn.COUNT(BookingModel.id).filter(BookingModel.status != 'cancelled')\r\n```\r\ndoes not work.", "Works fine for me:\r\n\r\n```python\r\nclass Person(Model):\r\n name = TextField()\r\n class Meta:\r\n database = db\r\n\r\nclass Pet(Model):\r\n person = ForeignKeyField(Person)\r\n animal = CharField()\r\n class Meta:\r\n database = db\r\n\r\ndb.create_tables([Person, Pet])\r\n\r\np1 = Person.create(name='Cat Lady')\r\np2 = Person.create(name='Dog Owner')\r\np3 = Person.create(name='Animal Lover')\r\nPet.create(person=p1, animal='Cat 1-1')\r\nPet.create(person=p1, animal='Cat 1-2')\r\nPet.create(person=p2, animal='Dog 2-1')\r\nPet.create(person=p2, animal='Dog 2-2')\r\nPet.create(person=p3, animal='Cat 3-1')\r\nPet.create(person=p3, animal='Dog 3-1')\r\nPet.create(person=p3, animal='Dog 3-2')\r\nPet.create(person=p3, animal='Fish 3-1')\r\n\r\nquery = (Person\r\n .select(Person.name,\r\n fn.COUNT(Pet.id).filter(Pet.animal.startswith('Cat')).alias('cats'),\r\n fn.COUNT(Pet.id).filter(Pet.animal.startswith('Dog')).alias('dogs'),\r\n fn.COUNT(Pet.id).alias('total_pets'))\r\n .join(Pet, JOIN.LEFT_OUTER)\r\n .group_by(Person.name))\r\nfor p in query:\r\n print(p.name, 'cats:', p.cats, 'dogs:', p.dogs, 'all:', p.total_pets)\r\n```\r\n\r\nPrints\r\n\r\n```\r\nAnimal Lover cats: 1 dogs: 2 all: 4\r\nCat Lady cats: 2 dogs: 0 all: 2\r\nDog Owner cats: 0 dogs: 2 all: 2\r\n```" ]

[]

[]

[ "peewee crate table in safe mode don't work at all????\r\n\r\n", "@jekoie You are supposed to do it like this:\r\n\r\n```\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass FQCModel(BaseModel):\r\n date_ = DateTimeField(default=datetime.datetime.now, help_text=\"日期\", verbose_name=\"日期\", index=True, formats=\"%Y-%m-%d %H:%M:%S\")\r\n\r\ndb.create_tables([FQCModel])\r\n```\r\n", "MySQL does not support create index if not exists, if I recall correctly. So you probably need to check yourself beforehand.", "You can get the list of existing tables and indexes:\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.get_tables\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.get_indexes", "@coleifer My Model is Ok, The real problem is `peewee` can't judge if the table already exist, so in I call `db.create_tables([FQCModel], safe=True)` again , it will be throw error.", "You meant to reply to mkmoisen I believe.\r\n\r\nHere is my comment, again:\r\n\r\nMySQL does not support create index if not exists, if I recall correctly. So you probably need to check yourself beforehand.\r\n\r\nAnd:\r\n\r\nYou can get the list of existing tables and indexes:\r\n\r\n http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.get_tables\r\n http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.get_indexes\r\n\r\n@jekoie you can always write your own method that checks for existence before trying to create the table." ]