Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "You are probably using sqlite and storing the datetimes in some unrecognizable format. If you look at the code you can see what format are supported out of the box. Using these formats is recommended because they allow for lexicographic ordering.\r\n\r\nThis is also explained in detail in the documentation:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/api.html#DateTimeField", "@coleifer Thanks for the quick response. This is how I'm setting the value:\r\n```\r\nIn [2]: from models import Entry\r\nIn [3]: entry = Entry()\r\nIn [4]: from datetime import datetime, timezone\r\nIn [5]: entry.created_at = datetime.now(timezone.utc)\r\nIn [6]: entry.save()\r\nOut[6]: 1\r\nIn [7]: entry.id\r\nOut[7]: 3\r\nIn [8]: entry = Entry.get(id=3)\r\nIn [9]: entry.created_at\r\nOut[9]: '2020-12-27 20:33:38.411859+00:00'\r\n```\r\n\r\nI'm setting it directly as a `datetime` object and `save()` works, but isn't it inconsistent to allow receiving a `datetime` and returning a `str` later?", "I'm using SQLite, yes.\r\nPeewee converts `datetime` to a string when saving to SQLite, why not convert it back as well?", "Don't store tz info. Just use naive datetimes in utc.", "That worked, thanks.\r\nThere should be an error thrown when trying to save with tzinfo saying it's not supported." ]

[]

[]

[ "Peewee doesn't support \"`<x is None>`\" expressions, for starters. This may have worked in previous versions, but it boils down to concatenating \"%\" with NULL and then performing a LIKE query - which is just gross.\r\n\r\nI suggest that you clean up your code and refactor those expressions. I think I'll mark this wontfix for now." ]

[]

[]

[]

[]

[]

[ "But if i do this , it works.\r\n```\r\nt = Topic.get_by_id(420426)\r\np = t.post\r\np.content = 'test'\r\np.save(only=[Post.content])\r\n```", "Every time you access `topic.post` using that property you are re-fetching a new instance (and the one you modified is discarded)." ]

[]

[]

[ "An un-saved model, by definition, will not have any dependencies -- so this does not strike me as a bug." ]

[]

[]

[ "The error indicates that you cannot connect to the server, so I fail to see how this is a peewee issue. Probably some docker networking issue on your end.\r\n\r\nCan you connect to the mysql server using the mysql cli on the same host as the code is running? That'd be the best place to start debugging. But yeah -- this does not sound at all like a peewee bug to me. You might also try asking of stackoverflow if you need help debugging your docker configs.", "Yeah tried with just pymysql and still erroring, sorry for the trouble, thank you @coleifer !" ]

[]

[]

[ "Putting it in a check constraint means needing to use a database-provided function. Unless you're using sqlite and will always have such a user-defined function available, I'm not sure how you would do this.\r\n\r\nPeewee does not really do validation in the `db_value()` or `python_value()` methods. This should be handled at the layer that is accepting user input, e.g. a web form. The `db_value()` and `python_value()` methods are solely intended for converting between python-native types and whatever the underlying storage engine driver returns. For example, converting a `Path` object to a string instance and vice-versa.\r\n\r\nThe handling of the validation would be better done somewhere up the stack, in my experience, where you will have a better chance of informing the user or caller of the problem and allowing them to fix the issue.", "Thanks for your clarification.\r\nI will always and only be using SQLite for the back-end. These are small projects for my personal use. Based on your feedback, I will move these Path validations to `check` functions managed by `@pre_init` decorators for the tables." ]

[]

[]

[ "Peewee uses a convention of implicitly assigning an auto-incrementing integer primary key named \"id\" (in the absence of the user explicitly declaring a column as the primary key). Since your table follows this convention, there is no need to explicitly declare the id field." ]

[]

[]

[ "Ok, I found that using mysqlclient instead of PyMySQL I can pass a `connect_timeout` option to `MySQLDatabase` that works as expected.", ">I can pass a connect_timeout option to MySQLDatabase that works as expected.\r\n\r\nPerfect." ]

[]

[]

[ ">But isinstance returns true even when the database is SqliteExtDatabase\r\n\r\nThat doesn't sound correct to me:\r\n\r\n```python\r\nIn [1]: from playhouse.sqlite_ext import SqliteExtDatabase\r\n\r\nIn [2]: from playhouse.postgres_ext import PostgresqlExtDatabase\r\n\r\nIn [3]: d1 = SqliteExtDatabase(':memory:')\r\n\r\nIn [4]: d2 = PostgresqlExtDatabase('peewee_test')\r\n\r\nIn [5]: isinstance(d1, PostgresqlExtDatabase)\r\nOut[5]: False\r\n\r\nIn [6]: isinstance(d2, SqliteExtDatabase)\r\nOut[6]: False\r\n```\r\n\r\nRe: custom aggregate, it seems working fine for me:\r\n\r\n```python\r\[email protected]('string_agg')\r\nclass StringAgg(object):\r\n def __init__(self):\r\n self._data = []\r\n\r\n def step(self, value):\r\n self._data.append(value)\r\n\r\n def finalize(self):\r\n return ', '.join(self._data)\r\n\r\nclass Reg(Model):\r\n key = TextField()\r\n class Meta:\r\n database = db\r\n\r\ndb.create_tables([Reg])\r\n\r\nReg.insert_many([{'key': 'k%02d' % i} for i in range(10)]).execute()\r\n\r\nprint(Reg.select(fn.string_agg(Reg.key)).scalar())\r\n# prints:\r\n#k00, k01, k02, k03, k04, k05, k06, k07, k08, k09\r\n```\r\n\r\nSo, in short, I don't know how to advise you because I cannot reproduce either issue you're describing.", "To follow up, the problem in solution one was that `database` is the initialised database, but my tests are wrapped in a closure. The solution was to use `Model._meta.database` so I had the actual database instance being used. That returned the right answer for `isinstance`.\r\n\r\nAs for the second problem, I'm still not sure why it wasn't working for me, but I ended up not using a string aggregation anyway." ]

[]

[]

[ "This came up recently related to array fields: #2292 - I believe this is either the same (or very similar) issue. I can't offer a fix for this at present and suggest the following workarounds:\r\n\r\n* write your Case() explicitly with the appropriate cast\r\n* begin a transaction and issue your updates one-at-a-time - profile this! it very likely may be just as performant", "Ok, I also considered doing single updates, I guess I'll go this way (especially since the app might also be used in SQLite-backed environments) and try to remember to not use such types in `bulk_update`.\r\nThank you for your quick answer and the link to some explanation.", "Yeah, I'm sorry to not be able to offer a fix right now. I think as long as you're using a transaction then updating individually should be fine, however.", "@coleifer Would you add this to the docs please, I have used a lot time to find this issue.\r\nI considered following methods:\r\n1) do not use non-integer primary key\r\n2) change name \"id\"(non-integer primary key) to \"idcard\"\r\nIt's difficult for noobs to know this issue.\r\n\r\nIf a noob saw a note in docs:\r\nNote:\r\nWhen using bulk_update, if there is a DatatypeMismatch error, and you are using postgresql.\r\nYou should use single update.\r\nbecause ...", "@yunlongYoung - those methods you outlined are not quite accurate and are not recommended. Bulk update works perfectly fine with a non-integer primary key (including UUID primary key), as well as any arbitrary pk column name, including \"id\".\r\n\r\nThe bulk-update works well generally across databases and field-types. The issue has to do with updating the UUID value in UUID fields (which seems like an odd thing to do anyways, but that's beside the point...). Postgres doesn't like it when we do something like:\r\n\r\n```sql\r\nSET \"uuid_col\" = (\r\n CASE \"id\" \r\n WHEN 1 THEN <some uuid>\r\n WHEN 2 THEN <some other uuid> \r\n END)\r\n```\r\n\r\nDetails can be read here: https://dba.stackexchange.com/questions/228046/why-do-i-need-to-cast-null-to-column-type/228058#228058\r\n\r\nThe accepted workaround is to simply make individual `UPDATE` queries." ]

[]

[]

[ "Read the manual\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#pgjson\r\n* http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#mysql-ext\r\n* http://docs.peewee-orm.com/en/latest/peewee/sqlite_ext.html#sqlite-json1" ]

[]

[]

[ "That data is not stored thread-local and you are advised that it is a bad idea. It's probably better to dynamically generate a model-class with the desired schema than to try swapping it around. Generally this is not going to be well-supported." ]

[]

[]

[ "I'm OK with adding this, but you should *really* be explicitly aliasing these so that it is not database-dependent and fragile. I believe, furthermore, this example is specific to sqlite - postgres behaves differently (I believe the columns will be named \"min\" and \"max\", at least that's how it behaves on my laptop with postgres 13), and older versions of sqlite behave even differently if I recall correctly.\r\n\r\nI've implemented a similar patch which also adds a test-case and merged.", "Thanks a lot for the answer. You're absolutely right about the aliasing necessity. I discovered this issue as part of some quick&dirty debugging, where i didn't take the time to alias (which I usually do). As it was quite straight forward to correct, I thought it was better to consolidate that in a PR." ]

[]

[]

[ "Thanks for the succinct issue report. For now I've made a provisional fix which correctly delegates to the `ForeignKeyField.db_value()` method when a model instance is converted. The fix is not perfect since we still want a way to convert model instances when a converter is present (but is not able to handle the given model instance), so I am catching possible `TypeError` or `ValueError`. I believe this should work in practice and have put some new tests in place.", "Many thanks." ]

[]

[]

[ "This code is covered by unit-tests and I believe it is working properly.\r\n\r\nhttps://github.com/coleifer/peewee/blob/efb41a944e926ea201d120e50d3d864028fbf899/tests/migrations.py#L392-L420" ]

[]

[]

[ ">I saw the data has been written into the database\r\n\r\nAssuming you mean you were using a separate connection and saw the data before it had been committed by the peewee connection? You might check your read [isolation settings](https://dev.mysql.com/doc/refman/8.0/en/innodb-transaction-isolation-levels.html).\r\n\r\nWhen I run the following script I get the expected output -- the 2nd connection does not see the uncommitted row until I call commit:\r\n\r\n```python\r\nfrom peewee import *\r\n\r\ndb = MySQLDatabase('peewee_test')\r\ndb2 = MySQLDatabase('peewee_test') # 2nd connection\r\n\r\nclass Reg(Model):\r\n key = TextField()\r\n class Meta:\r\n database = db\r\n\r\nclass Reg2(Reg): # model class for accessing table using 2nd conn\r\n class Meta:\r\n database = db2\r\n table_name = 'reg'\r\n\r\n\r\ndb.create_tables([Reg])\r\n\r\nwith db.manual_commit() as tx:\r\n db.begin()\r\n Reg.create(key='k1') # create a row using first conn\r\n\r\n db2.connect() # query table using 2nd conn\r\n print('is \"k1\" visible to conn2 BEFORE commit?')\r\n print('rows in \"reg\" table: %s' % Reg2.select().count())\r\n\r\n db.commit()\r\n print('is \"k1\" visible to conn2 AFTER commit?')\r\n print('rows in \"reg\" table: %s' % Reg2.select().count())\r\n\r\n db2.close()\r\n\r\ndb.drop_tables([Reg])\r\n```\r\n\r\nOutput:\r\n\r\n```\r\nis \"k1\" visible to conn2 BEFORE commit? \r\nrows in \"reg\" table: 0 \r\nis \"k1\" visible to conn2 AFTER commit? \r\nrows in \"reg\" table: 1\r\n```", "@coleifer Thank you very much for your reply. I am sure it is not an isolated problem. After a script has been executed, I entered select * from spead on the mysql command line and found that the data has indeed been written. In order to avoid my MYSQL problem, I tested it with the command line in mysql, and this problem did not appear，Did you execute it on mysql 8.0?", "I will execute these commands in mysql without any problems, but the peewee script will be written into the database without executing the commit.\r\n\r\n```\r\nroot@ubuntu-PowerEdge-R740:~# mysql -h 127.0.0.1 -uroot -pxxxxx\r\nmysql: [Warning] Using a password on the command line interface can be insecure.\r\nWelcome to the MySQL monitor. Commands end with ; or \\g.\r\nYour MySQL connection id is 94\r\nServer version: 8.0.22 MySQL Community Server - GPL\r\n\r\nCopyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.\r\n\r\nOracle is a registered trademark of Oracle Corporation and/or its\r\naffiliates. Other names may be trademarks of their respective\r\nowners.\r\n\r\nType 'help;' or '\\h' for help. Type '\\c' to clear the current input statement.\r\n\r\nmysql> use address;\r\nReading table information for completion of table and column names\r\nYou can turn off this feature to get a quicker startup with -A\r\n\r\nDatabase changed\r\nmysql> set autocommit=0;\r\nQuery OK, 0 rows affected (0.00 sec)\r\n\r\nmysql> begin;\r\nQuery OK, 0 rows affected (0.00 sec)\r\n\r\nmysql> insert into spead values(1,'test1','11','11');\r\nQuery OK, 1 row affected (0.00 sec)\r\n\r\nmysql> select * from spead;\r\n+----+-------+--------+-------+\r\n| id | dis | number | value |\r\n+----+-------+--------+-------+\r\n| 1 | test1 | 11 | 11 |\r\n+----+-------+--------+-------+\r\n1 row in set (0.00 sec)\r\n\r\nmysql> exit;\r\nBye\r\nroot@ubuntu-PowerEdge-R740:~# mysql -h 127.0.0.1 -uroot -pxxxx\r\nmysql: [Warning] Using a password on the command line interface can be insecure.\r\nWelcome to the MySQL monitor. Commands end with ; or \\g.\r\nYour MySQL connection id is 95\r\nServer version: 8.0.22 MySQL Community Server - GPL\r\n\r\nCopyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.\r\n\r\nOracle is a registered trademark of Oracle Corporation and/or its\r\naffiliates. Other names may be trademarks of their respective\r\nowners.\r\n\r\nType 'help;' or '\\h' for help. Type '\\c' to clear the current input statement.\r\n\r\nmysql> use address;\r\nReading table information for completion of table and column names\r\nYou can turn off this feature to get a quicker startup with -A\r\n\r\nDatabase changed\r\nmysql> select * from spead;\r\nEmpty set (0.00 sec)\r\n\r\nmysql> \r\n```\r\n\r\nMy script is just the following lines\r\n\r\n```\r\nfrom peewee import *\r\ndb = MySQLDatabase(\"address\", host=\"127.0.0.1\", port=3306, user=\"root\", passwd=\"xxxx\",autocommit=False,autorollback=True)\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass Spead(BaseModel):\r\n dis = CharField(unique=True)\r\n number = IntegerField(null=True)\r\n value = IntegerField(null=True)\r\n\r\n\r\n\r\n```\r\n", "I'm using mariadb 10.4.x. The script I shared clearly shows that the rows are not visible to the 2nd connection before they have been committed. You might try running it and seeing if you get the same output as I do.", "Thanks, my code problem, sorry" ]

[]

[]

[ "http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.get" ]

[]

[]

[ "Questions belong on stack overflow or you can ask in IRC. This is covered here: http://docs.peewee-orm.com/en/latest/peewee/contributing.html#questions\r\n\r\nI'm not sure what you mean by \"query the gdmc field\", so I'm guessing you mean test it's value?\r\n\r\n```python\r\n\r\n# test if the \"gdmc\" field equals some value.\r\nModelX.select().where(ModelX.sdgdList['gdmc'] == 'some value')\r\n```" ]

[]

[]

[ "Going to pass. Presumably you are validating untrusted user input in the input layer, or relying on database constraints for the sql layer." ]

[]

[]

[ "This came up recently and it is not something I plan to support. See:\r\n\r\nhttps://github.com/coleifer/peewee/issues/2275", "OK, thanks anyway for the answer and support and sorry to have overlooked the existing issue (only looked for the opened ones, I admit).\r\n", "No problem. Like I said in the last issue, the problem is we have no way to map the \"successful\" IDs to the corresponding instances because of how postgres returns the data." ]

[]

[]

[ "See: http://docs.peewee-orm.com/en/latest/peewee/query_operators.html#row-values" ]

[]

[]

[ "That's odd. The line you're referencing, 305, is wrapped in a try/except on `ImportError`, as is the code in `sqlite_ext.py` which attempts to import from the C extension. This doesn't seem to be an error, but rather a warning?\r\n\r\nThe `pyx` file is the cython source file, which gets compiled into a C extension. Is your code trying to read the pyx file, or what is going on there?", "Okay so for more context the error only happens when `pytest` is run since the file in question that imports `PooledPostgresqlExtDatabase ` is imported in `pytest`'s conftest.py. Running it through uvicorn works otherwise. ", "I think this may be the related issue https://github.com/cython/cython/issues/1720 - I'm not sure why this occurs only for 3.14 but not 3.13.3, though?", "Probably? What should be a workaround for this? ", "I don't see anything in the diff that seems relevant to this issue: https://github.com/coleifer/peewee/compare/3.13.3...3.14.0\r\n\r\nAlso, as far as I can tell this isn't a bug, but rather you're receiving a warning during testing. You might try recompiling, or upgrading cython and rebuilding?", "Hmm. This happens on a fresh install/run on a CI though. Still a cython issue? ", "I don't know, honestly. I don't see the issue running the peewee tests https://travis-ci.org/github/coleifer/peewee and I really don't see anything between versions 3.13.3 and 3.14.0 that seems relevant.", "@coleifer found an issue related to this: https://github.com/pytest-dev/pytest/issues/4423 and it seems like it is Cython issue that and he ended up building it with a newer version of Cython to get it working. Might help. ", "@coleifer more info: when I install peewee 3.14.0 from source, it works no problem. So maybe something else happened when 3.14.0 was released in pypi? ", "Final context to those who might stumble upon this: [email protected] works in Python 3.9 and not on 3.8. I haven't tested for lower versions. However, 3.14.1 and 3.14.2 works on both 3.9 and 3.8. I still think that there was something wrong with how 3.14.0 was built. " ]

[]

[]

[ "Yes, this was a design decision. If you omit the model how will you traverse the graph?", "I can't continue traversing the graph if some _node_ will have all fields equal to None. But it gives the wrong info that the node (model) _exists_. So, this decision doesn't give benefits.\r\n\r\nFor traversing I use the following helper function:\r\n```\r\ndef get_deep(obj_dic, *keys):\r\n if not keys:\r\n return obj_dic\r\n if obj_dic is None:\r\n return None\r\n if isinstance(obj_dic, dict):\r\n return get_deep(obj_dic.get(keys[0], None), *keys[1:])\r\n else:\r\n return get_deep(getattr(obj_dic, keys[0], None), *keys[1:])\r\n```", "Ok, I follow your point. Not all fields are None, but the chain fields are not None. Anyway, it requires different ways to check the existence of an intermediate and of the last node.\r\n\r\nWhat are your views on adding the last model to the chain as well? It will give the ability to add a helper method that will answer: does the model exists or not? It will also be universal for all nodes in the chain of joins." ]

[]

[]

[ "You're joining on `B` but you're selecting from `B_al`. The following works just fine for me:\r\n\r\n```python\r\nfrom peewee import *\r\n\r\ndb = SqliteDatabase(':memory:')\r\nclass Base(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass A(Base):\r\n a = IntegerField()\r\n\r\nclass B(Base):\r\n b = IntegerField()\r\n a = ForeignKeyField(A)\r\n\r\ndb.create_tables([A, B])\r\n\r\na1 = A.create(a=1)\r\nb1_1 = B.create(id=100, a=a1, b=11)\r\nb1_2 = B.create(id=101, a=a1, b=12)\r\n\r\nB_a = B.alias()\r\nq = A.select(B_a.id, A.id).join(B_a)\r\nfor row in q:\r\n print(row.get_id(), row.b.id)\r\n\r\n# outputs\r\n# 1 100\r\n# 1 101\r\n```", "I had a typo on my previous text. I meant `join(B_al)` instead of `join(B)`.\r\nThe method `get_id()` still returns the foreign key of the model instance (tested on sqlite).\r\npeewee version: 3.13.3\r\n\r\nI put the corrected query once again here\r\n\r\n```python\r\nB_al = B.alias()\r\nret = A.select(B_al.id, A.id)\r\nret = ret.switch(A).join(B_al).objects()\r\nfor r in ret:\r\n print(r.get_id()) \r\n````\r\n", "You are explicitly asking peewee to patch all attributes onto a single instance by calling `.objects()`, so this is completely expected. Your cursor has 2 values, eached named \"id\" (for A and B). When you call \".objects()\" you're telling peewee to just put all cursor values directly onto a single instance, so you're overwriting A's \"id\" with the \"id\" for B.\r\n\r\nSolutions:\r\n\r\n* do not use .objects()\r\n* alias B's id to some other attribute", "Ah, I see.\r\nThank you!!" ]

[]

[]

[ "Thanks, this is a bad regression. I've patched this and will make a new release early in the week.", "Scratch that, never put off til tomorrow what you can do today, and all that.\r\n\r\nI've tagged and released a new version 3.14, which contains this fix. Thanks again for the excellent bug report.", "wow, that was fast. thanks for the great work, really appreciate it.", "just tried this after the update and can confirm it works correctly. one question though - the `~DQ(id = orig_bill_item.id)` expression generates this sql fragment: `NOT (\"t1\".\"idriadok\" = %s)`. this makes sense of course, but my question is: is there a way to get `\"t1\".idiriadok\" != %s` using django-style lookups?", "You can do `id__ne=orig_bill_item.id`.", "Oh, cool, thanks. Maybe I missed something, but I couldn't find any documentation for these, so I supposed the lookups will match the ones documented [here](https://docs.djangoproject.com/en/3.1/ref/models/querysets/#field-lookups) and there's no `__ne`." ]

[]

[]

[ "psycopg2 uses \"%s\" for all parameter placeholders, and automatically converts `None` to `NULL` so I do not believe this is the issue. To be honest this one has me stumped, as entering the following into the postgres shell also fails with the same error:\r\n\r\n```sql\r\nupdate users \r\nset emails = case users.id when 1 then null end\r\nwhere users.id = 1\r\n```\r\n\r\nThe issue is that postgres wants us to explicitly cast the result of `case` expression:\r\n\r\n```sql\r\n-- this works\r\nupdate \"users\" set emails = cast(\r\n case \"users\".\"id\" when 1 then NULL end\r\n as character varying[])\r\nwhere (\"users\".\"id\" in (1));\r\n```\r\n\r\nI think I'm just going to have to mark this for now as wontfix since it works fine when you specify an actual list of names. I won't go so far as to say this is a postgres bug, but it certainly feels like one as it works fine with an actual array of emails and only throws an error if you pass an (equally-valid) NULL value.\r\n\r\nThanks for the helpful report. I will update the issue if anything changes.", "Thanks for the insight. You're right. It appears to be known behavior for Postgres, see for example: https://dba.stackexchange.com/a/228058\r\n\r\nI still think it's something where Peewee or Postgres or maybe even psycopg2 could improve the user experience. I'm just not sure where the best place to ask for an improvement is." ]

[]

[]

[ "You're overthinking this. It is quite simple:\r\n\r\n```python\r\n\r\ncutoff = datetime.datetime.now() - datetime.timedelta(minutes=60)\r\nquery = Zayavki.select().where(Zayavki.req_data >= cutoff)\r\n```\r\n\r\nAs to why this doesn't work, you cannot access the \".seconds\" attribute on a peewee expression, as the error clearly states. This is because it's not a `timedelta` object, but rather a representation of a SQL expression." ]

[]

[]

[ "Pycharm is probably calling all kinds of stuff. Specifically it's probably evaluating the truthiness or len(). Definitely not a peewee bug. I'd take it up with the pycharm folks.\r\n\r\nUsing a regular python repl or ipython has no problems at all.", "Alright thanks for the feedback!" ]

[]

[]

[ "Can you share the SQL for the query you're trying to write? It might be easier for me to help you work backwards from that.", "Sure, I'm trying to write something like this:\r\n\r\n```SQL\r\nWITH vehicle_insert (id) AS (\r\n INSERT INTO vehicle (uid, type_id, provider_id)\r\n VALUES ('Some:ID', 2, 3)\r\n ON CONFLICT DO NOTHING RETURNING id\r\n)\r\nSELECT id\r\nFROM vehicle\r\nWHERE ((uid = 'Some:ID') AND (provider_id = 3))\r\nUNION ALL\r\nSELECT id\r\nFROM vehicle_insert\r\n```\r\nI have a unique index on ```uid``` and ```provider_id```, so the query will get the id from the vehicle table if a matching row exists, or it will return the result from the returning clause if it doesn't exist.\r\n\r\nI also noticed from my example above that the call to ```union_all``` should be:\r\n```Python\r\nunion_all(vehicle_insert.select(vehicle_insert.c.id))\r\n```\r\nBut it doesn't solve the problem.", "I needed to add a small patch to the `CompoundSelectQuery` implementation to properly handle cte's bound to the union itself. I was able to get an *almost* correct query except for the parentheses, but now I've got a working query and the syntax isn't too awkward. The main takeaways are:\r\n\r\n1. the cte needs to be declared explicitly (as you are doing in your code), since I don't have `cte()` method support on the data modifying queries yet (see #2152).\r\n2. the cte needs to be bound to the union so that it ends up in the outermost layer\r\n3. we need to also explicitly create the bit that selects from the CTE since peewee's `CTE.select_from()` assumes you want to bind the cte to the select.\r\n\r\nHere is the code:\r\n\r\n```python\r\n\r\niq = (Vehicle\r\n .insert(uid=1, type='car', provider='p1')\r\n .on_conflict_ignore()\r\n .returning(Vehicle.id))\r\n\r\ncte = CTE('vehicle_iq', iq, columns=('id',))\r\n\r\nq1 = (Vehicle\r\n .select(Vehicle.id)\r\n .where((Vehicle.uid == 1) & (Vehicle.provider == 'p1')))\r\nq2 = Select([cte], [cte.c.id])\r\n\r\nu = q1.union_all(q2).with_cte(cte)\r\n```\r\n\r\nThis patch is needed as well: 92494cd9ed01b12826b2fddb25cde221ea34f155\r\n\r\nI'm going to close this for now and will look at reducing some of these clumsier pieces as part of #2152." ]

[]

[]

[ "merged an equivalent patch" ]

[]

[]

[ "I don't have enough information to help debug this. Can you provide the query?", "('INSERT INTO `t_group` (`c_id`, `c_group_name`, `c_group_code`, `c_doc_ids`, `c_company_id`, `c_is_delete`, `c_add_by`, `c_add_dt`, `c_update_dt`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)', ['185ede639b654695869c87b28d31b28d', 'data', '02', '', 'cdf49474297c4454aa2d410ba5eacf60', False, 'user_id', datetime.datetime(2020, 10, 27, 19, 2, 35, 675031), datetime.datetime(2020, 10, 27, 19, 2, 35, 675045)])\r\n", "when running insert_many get error.\r\n\r\nawait db_manager.execute(\r\n Group.insert_many(group_list)\r\n)\r\n", "This looks like possibly a issue with peewee async? If you can provide a reproducible test that fails I will look into this some more, but `insert_many()` and all this is covered by existing (passing) tests, so I don't think there is anything fundamentally broken here." ]

[]

[]

[ "By default peewee databases use a connection-per-thread." ]

[]

[]

[ "First off, please take the time to format your code properly. GitHub has links and controls in the editor that will show you how to do this.\r\n\r\nSecond, please see the documentation. This is covered in all the basic examples.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/quickstart.html#model-definition\r\n\r\n```python\r\nclass SomeModel(Model):\r\n ...\r\n class Meta:\r\n database = db_instance\r\n```" ]

[]

[]

[ "Excellent, thank you!" ]

[]

[]

[ "I cannot replicate this problem:\r\n\r\n```python\r\n\r\nfrom peewee import *\r\n\r\ndb = SqliteDatabase(':memory:')\r\n\r\nclass Base(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass User(Base):\r\n username = TextField()\r\n\r\nclass Tweet(Base):\r\n user_id = ForeignKeyField(User, backref='tweets')\r\n\r\ndb.create_tables([User, Tweet])\r\ndb.execute_sql('drop index \"tweet_user_id\"')\r\n\r\nfrom playhouse.migrate import *\r\nmigrator = SchemaMigrator.from_database(db)\r\nmigrate(\r\n migrator.add_index('tweet', ('user_id',), unique=True)\r\n)\r\n```\r\n\r\nThe SQL being generated is correct in the above example:\r\n\r\n```sql\r\nCREATE TABLE IF NOT EXISTS \"user\" (\"id\" INTEGER NOT NULL PRIMARY KEY, \"username\" TEXT NOT NULL)\r\nCREATE TABLE IF NOT EXISTS \"tweet\" (\"id\" INTEGER NOT NULL PRIMARY KEY, \"user_id\" INTEGER NOT NULL, FOREIGN KEY (\"user_id\") REFERENCES \"user\" (\"id\"))\r\n-- this is added automatically by peewee --\r\nCREATE INDEX IF NOT EXISTS \"tweet_user_id\" ON \"tweet\" (\"user_id\")\r\n-- we'll drop the automatically-added index explicitly --\r\ndrop index \"tweet_user_id\"\r\n\r\n-- this is generated by the migrator --\r\nCREATE UNIQUE INDEX \"tweet_user_id\" ON \"tweet\" (\"user_id\")\r\n```\r\n\r\nAlso, for what it's worth, using \"master_id\" is a bit of an anti-pattern, since the field accessor returns an `AnotherThing` instance and not a numeric/unique ID." ]

[]

[]

[ "Just going to read it with `folds = {int(k):v for k,v in folds.items()}` when I need that attribute.\r\n\r\nMakes me think of this:\r\n", "What database are you using? Postgres, Sqlite or MySQL?", "@coleifer Sqlite\r\n```\r\nfrom playhouse.sqlite_ext import SqliteExtDatabase, JSONField\r\n```", "I think this comes down to sqlite interpreting object keys as strings. I'd suggest following it up on the sqlite forums if you have more questions on it. https://sqlite.org/forum/forummain\r\n\r\n```\r\nsqlite> select json_valid('{1: \"k1\"}');\r\n0\r\nsqlite> select json_valid('{\"1\": \"k1\"}');\r\n1\r\n```", "@coleifer Thanks for taking a look. Your `json_valid` test got me on the right track. There are several posts out there pointing to the JSON spec saying that keys must be strings. E.g. https://stackoverflow.com/a/8758771/5739514\r\n\r\nLet's see what the sqlite folks say. Surprised it allows it to be stored.\r\nhttps://sqlite.org/forum/forumpost/28863dcedf\r\n\r\nTaking a look at MongoDB, they use a lot of this pattern, but it results in `TypeError: unhashable type: 'list'`. Will keep thinking on a workaround apart from another rel/table.\r\n```\r\n{[\r\n {\r\n \"_id\": 1,\r\n \"attribute1\": \"beep\"\r\n },\r\n {\r\n \"_id\": 2,\r\n \"attribute2\": \"boop\"\r\n }\r\n]}\r\n```", "Workaround for future humans\r\n```\r\nfolds = {\"folds\": [{\"id\":1, \"name\":\"a\", \"other\":\"beep\"}, {\"id\":2, \"name\":\"b\", \"other:\"boop\"}]}\r\n# or\r\nfolds = {\"folds\": [{\"name\":\"a\", \"other\":\"beep\"}, {\"name\":\"b\", \"other\":\"boop\"}]}\r\n```\r\nKinda stinks but at least the inner list can be accessed via index in python. `Foldset.folds[\"folds\"][0]`" ]

[]

[]

[ "```python\r\nIn [1]: from peewee import * \r\n\r\nIn [2]: class MyModel(Model): \r\n ...: pass \r\n ...: \r\n\r\nIn [3]: MyModel.bulk_update \r\nOut[3]: <bound method Model.bulk_update of <Model: MyModel>>\r\n```" ]

[]

[]

[ "```python\r\n\r\nfrom peewee import * \r\n\r\ndb = SqliteDatabase(':memory:')\r\n\r\nimport logging\r\nlogger = logging.getLogger('peewee')\r\nlogger.addHandler(logging.StreamHandler())\r\nlogger.setLevel(logging.DEBUG)\r\n\r\nclass Base(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass A(Base):\r\n a = TextField()\r\nclass B(Base):\r\n a = ForeignKeyField(A)\r\n b = TextField()\r\nclass C(Base):\r\n b = ForeignKeyField(B)\r\n c = TextField()\r\n\r\nall_tables = [A, B, C]\r\nfor table in all_tables:\r\n table._meta.sorted_fields\r\n table._meta.add_field('test', TextField())\r\n\r\ndb.create_tables(all_tables)\r\n```\r\n\r\nOutput:\r\n\r\n```\r\n('CREATE TABLE IF NOT EXISTS \"a\" (\"id\" INTEGER NOT NULL PRIMARY KEY, \"a\" TEXT NOT NULL, \"test\" TEXT NOT NULL)', []) \r\n('CREATE TABLE IF NOT EXISTS \"b\" (\"id\" INTEGER NOT NULL PRIMARY KEY, \"a_id\" INTEGER NOT NULL, \"b\" TEXT NOT NULL, \"test\" TEXT NOT NULL, FOREIGN KEY (\"a_id\") REFERENCES \"a\" (\"id\"))', [])\r\n('CREATE INDEX IF NOT EXISTS \"b_a_id\" ON \"b\" (\"a_id\")', []) \r\n('CREATE TABLE IF NOT EXISTS \"c\" (\"id\" INTEGER NOT NULL PRIMARY KEY, \"b_id\" INTEGER NOT NULL, \"c\" TEXT NOT NULL, \"test\" TEXT NOT NULL, FOREIGN KEY (\"b_id\") REFERENCES \"b\" (\"id\"))', [])\r\n('CREATE INDEX IF NOT EXISTS \"c_b_id\" ON \"c\" (\"b_id\")', [])\r\n```" ]

[]

[]

[ "I've merged an equivalent patch. I had hoped to also support `map` but that's more like a generator and doesn't support multiple iterations, so that doesn't work. At any rate, thanks for the suggestion." ]

[]

[]

[ "F-Strings are not supported in Python 2.x and Python 3 < 3.6.\r\nThis is why the check fails.", "I see that, thanks! :+1: Didn't think it was worth fixing right away since I imagine changes will be needed anyway, if this is at all even wanted. ", "I'm not interested in maintaining or supporting this, but feel free to offer it as a 3rd-party extension.", "Thank you for your input.\r\n\r\nI don't see anything similar to [Computed](https://docs.sqlalchemy.org/en/13/core/defaults.html?highlight=server#computed-generated-always-as-columns) offered by Peewee (at least I couldn't locate anything in the docs), or is this the right approach?", "No but since Postgres, MySQL and Sqlite have roughly the same syntax it's probably worth adding. I will look into this.", "As I was implementing this, I ran into a number of subtle differences between the Sqlite, MySQL, MariaDB and Postgres implementations. For now, I think users will be best-off using the existing `constraints=` parameter to specify a generated column definition, although the code is in `feature/computed` branch if you want to fork it.\r\n\r\n```python\r\n\r\nconstraint = SQL(\"generated always as (first || ' ' || last)\")\r\nfull_name = CharField(constraints=[constraint])\r\n```", "Lovely! Thanks for the tip, I really appreciate it. " ]

[]

[]

[ "To delete a single model instance, you should use `.delete_instance()`.\r\n\r\nThe documentation covers this in detail: http://docs.peewee-orm.com/en/latest/peewee/querying.html#deleting-records" ]

[]

[]

[ "The default is only removed if the original field instance has a default, so this seems like something that only would come about in a very weird way. Going to pass on any changes." ]

[]

[]

[ "I'm going to pass on implementing this as part of `bulk_create()` since this can be easily handled by:\r\n\r\n```python\r\nModel.insert_many([....]).on_conflict_ignore()\r\n```\r\n\r\nThe problem arises w/postgres where the insert cursor returns IDs only for the rows that are created, which can't be mapped back to the actual objects that were inserted." ]

[]

[]

[ "That's not the correct way. An iterable of 2-tuples looks like this:\r\n\r\n```python\r\n[('key1', 'Label 1'), ('key2', 'Label 2')]\r\n```" ]

[]

[]

[ "I think you've got some issue with your code, your base model class, or something. What you're suggesting is that peewee is somehow fundamentally broken, and the tests are all passing:\r\n\r\nhttps://travis-ci.org/github/coleifer/peewee" ]

[]

[]

[ "You should not call `.select()` twice. Just build up your joins. I suggest you familiarize yourself with the documentation, which covers many topics like querying and joins:\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/querying.html\r\n* http://docs.peewee-orm.com/en/latest/peewee/relationships.html\r\n\r\nReferencing the same table twice, but in different contexts, is done with an alias:\r\n\r\n```python\r\nDA = Deployment.alias()\r\n\r\nquery = (System\r\n .select() # If you want all columns, use \".select(System, Deployment, DA)\" instead\r\n .join(Deployment, on=(System.deployment == Deployment.id), attr='deployment')\r\n .join_from(System, DA, JOIN.LEFT_OUTER, on=(System.dataset == DA.id), attr='dataset'))\r\n```" ]

[]

[]

[ "I don't have any plans to add such, but you are welcome to write a monkey-patch for AliasManager.add and maintain it separately for your own debugging purposes." ]

[]

[]

[ "If you read the peewee code for `CursorWrapper` you will see that peewee is not eagerly fetching anything. The behavior you are seeing is a side-effect of the interaction between pysqlite (the stdlib sqlite driver) and how sqlite operates. You can see that [here](https://github.com/coleifer/pysqlite3/blob/master/src/cursor.c#L710-L772) pysqlite fetches the next row.\r\n\r\nI'd suggest that you're doing something weird and should probably a) read all rows first, or b) not modify them while iterating over the cursor. Ordinarily this isn't a problem if you are using separate connections to do the reading/modifying because this is either completely prevented or, if using wal-mode, the read operates on a snapshot. It only can occur if you're modifying the table and iterating at the same time, which seems problematic for what I hope are obvious reasons.", "Thank you for the quick response! I figured it was something wrong with my understanding of this.\r\n\r\nThankfully I was not building actual code, just experimenting with the details of how the .iterator() worked. I was essentially wanting to see what would happen using different processes, and I didn't know about the other ways this is prevented. Thank you, and great work on this package!" ]

[]

[]

[ "Thanks, I've made the change as suggested (although it is `if only is not None`). Peewee is active-record so calling save with no data will raise a `ValueError`." ]

[]

[]

[ "I have no plans at present to support this. It should be easy, if you so desire, to implement an `EnumField` as a separate class." ]

[]

[]

[ "Thanks merged an equivalent patch w/slightly different wording." ]

[]

[]

[ "The meta class is a weird kind of a hack inspired by similar deal in Django. The meta class is not what gets inherited, but instead the \"inheritable\" settings of the Meta class are inherited by the model.\r\n\r\nEx:\r\n\r\n```python\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass Foo(BaseModel):\r\n class Meta:\r\n table_name = 'foo_tbl'\r\n # \"database\" setting is inherited from BaseModel.\r\n```\r\n\r\nThis is described in the documentation for model options and table metadata:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#model-options-and-table-metadata", "OK, that works for me, but it's different from Django. https://docs.djangoproject.com/en/3.1/topics/db/models/#meta-inheritance" ]

[]

[]

[ "Since you are already explicitly specifying the `model_list` this seems redundant.", "It's not – think of my use case as \"defensive\" bulk updating of an attribute, for example allow only changes to `x` if `x` wasn't ever set and still has its default value of 0.\r\n\r\nI *think* this can be done in Django as follows, but I'm not entirely sure (haven't tried):\r\n\r\n```py\r\nFoo.objects.filter(x=0).bulk_update(foos, ['x'])\r\n```\r\n\r\nAs an alternative, what do you think about factoring out the `Case` builder logic from `bulk_update` into a public helper method so it's easier for people to write their own custom bulk update logic?", "I'm not clear why you would be using bulk_update in that case? Presumably a regular-old update() query would work better?", "Because the `x` may be different for each `Foo`. Say we start with 3 `Foo` in the database, with `x`=0. We do some work that computes 3 new (different!) `x` values, and we want to update all of the `Foo`s with the new `x` values, with a single SQL update statement and in a way that never updates any `x` that were updated by something else while we were computing the new `x` values (race conditions).", "A relational database provides atomicity and isolation, so presumably there's a different way to handle that. I think this is a rather obscure usage because it implies that you are updating values from a list of models, but also that some of those models may be \"out-of-sync\". This, to me, is not an API failure but rather a result of trying to shoehorn some logic into a process that would be better handled another way.", "Isn't the scenario simply a case of a more general version of optimistic locking as described in the docs? http://docs.peewee-orm.com/en/latest/peewee/hacks.html#optimistic-locking There we have a version column, and no bulk update; here we have a non-version column with bulk update." ]

[]

[]

[ "Just define which models or foreign-keys to exclude and they won't be traversed. Alternatively, you can explicitly implement your serialization strategy.", "Oh wait, I think I understand now -- no, this is something you will probably want to implement in a custom serializer if you want to control how the back-references are also queried.", "Alright, thank you.\r\nI am currently doing it as follows,\r\n\r\n`occurrences` is my `backref`\r\n\r\n```\r\n _result = MyModel.select().where(conditions).limit(limit)\r\n results = []\r\n for _result in _results:\r\n result = model_to_dict(_result)\r\n result['occurences'] = [\r\n model_to_dict(occurence, backrefs=True)\r\n for occurence in _result.occurences.limit(limit)\r\n ]\r\n results.append(result)\r\n```\r\n\r\nI suppose this is the proper / (only?) way then?", "That's perfectly fine way, and what I would probably do as well. The next step up would be a dedicated serialization library." ]

[]

[]

[]

[]

[]

[ "No plans to support this, but feel free to implement as a 3rd-party extension." ]

[]

[]

[ "I'm not sure how to answer this, but I'd suggest providing examples and asking on stackoverflow. This sounds more like a question rather than a peewee-specific issue." ]

[]

[]

[ "This is why the `batch_size` is exposed. Performing bulk updates necessarily involves a lot of variables because you essentially have to provide a mapping from each primary-key to the values that are to be updated. I don't know of any other way to do this when each row may have a different value.\r\n\r\nNot a bug, that's simply how it works.\r\n\r\nWith sqlite you can probably just as efficiently open a transaction and apply the updates one-at-a-time." ]

[]

[]

[ "Can you produce a test-case that illustrates what you believe to be the problem? Without seeing what the order dicts look like it's hard to say.", "I'm a little confused as to how to reproduce this bug or what exactly your intent is. The whole reason to use a hybrid property is to express a computation (or scalar function) that would be useful both on a model instance and when querying against a model class. A setter is only assignable on an instance, not on a class. So what you really want is just a regular property, if I understand correctly. A reason this seems to work on `create()` but not `insert_many()` (I'm inferring this is why you're confused) is because when a model is instantiated the keyword args are applied to the instance, which has the effect (in your example) of setting the value.\r\n\r\nSince you are storing your timestamp in the database as a date-time field, then it seems to me that you are going through all this trouble just to set the field to a datetime during creation. This isn't at all the purpose of hybrid properties. See the [documentation](http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#hybrid-attributes) for examples.", "Apologies, I posted this and went to bed, which is why I didn't respond until many hours later. Clearly you run a very tight ship here! :blush: \r\n\r\n> So what you really want is just a regular property, if I understand correctly.\r\n\r\nYes, I think you have understood correctly and I may have misunderstood the purpose of a **hybrid** property needing to be useful both on a model instance and class.\r\n\r\n> A reason this seems to work on `create()` but not `insert_many()` (I'm inferring this is why you're confused) is because when a model is instantiated the keyword args are applied to the instance, which has the effect (in your example) of setting the value.\r\n\r\nCorrect again. So if I define a regular property, will `insert_many()` invoke it when attempting to insert each row?\r\n\r\nMy intent here is hopefully clear by now: to house simple conversion logic in the peewee model, as it is clearly the best place to implement an abstraction layer between code using millisecond epoch integers and a database requiring timestamps. Obviously this is possible with model by model instantiation, but I'm wondering if the **bulk** operations in peewee would see it work the same way?\r\n\r\nThe reasoning behind this is that my data processing code doesn't deal with the specifics of any model - its purpose is largely to receive data from one source and put it in the database - so it is written generically to handle multiple arbitrary source/model pairs. I planned to put the small conversion logic needed between source and database format in the peewee models as properties. I receive data in blocks of 100,000 rows so figured it was most efficient to use `insert_many` under `with db.atomic():`. Now I realise that `insert_many` won't invoke the property logic?\r\n\r\nShould it?\r\n\r\nIn short, I am trying to combine the convenience of 'upsert' type functionality with properties and the speed improvements suggested in the documentation at https://docs.peewee-orm.com/en/3.4.0/peewee/querying.html#bulk-inserts ... perhaps that's not possible?", "It seems like the most important thing you want to achieve is simply converting a ms timestamp to a datetime. This can be done by:\r\n\r\n1. subclassing a field and implementing a `db_value()` method that converts the timestamp to a datetime\r\n2. pre-processing your data\r\n\r\nSince it's specific to your data-source, it seems to me that you're better of pre-processing these timestamps - but that's up to you. See how `TimestampField` is implemented if you're curious.", "Of course you are right in this scenario, however the example I gave was just a small one. \r\n\r\nIt reality, the task is far greater - for example a lot of the input data needs simple changes (like this one) or code lookups. \r\n\r\nI can appreciate your thinking \"why don't you simply pre-process your data?!\", but for me it is about design elegance and common sense co-location of code: if I already have to enumerate a data model for Peewee, the most sensible place to perform minor field specific tranformations is in that same space - as opposed to having a code block someplace else that picks through fields and does transformations before data gets to peewee.\r\n\r\nIn my view of things, if peewee related code can do 'all things data', code in my other files can simply focus on using peewee at the model level, without bloating over field manipulations.\r\n\r\nJust my view.\r\n\r\nThanks for your help! I may end up subclassing fields as you say, and detecting the field name and selectively transforming it based on model name and field name outsourced to a YAML config file or similar ... sounds more complicated / less elegant than what I was originally thinking but ... ", "Tightly coupling my bulk-loading code (a 1-time operation) with my model code is exactly the kind of thing I would avoid. I'd write a function to process the data.", "Oh I see, you see your bulk loading code as a 1 time operation, which is likely true for a lot of cases. In my case, its happening every couple of minutes...which is why my original code had an `on_conflict` part. So for me that processing has to happen somewhere, it's just a matter of where. \r\n\r\nI see your point of view-I may just end up writing a simple configurable transformation engine then.", "It's a write-once operation." ]