Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "Fixed. As a workaround until I tag a new release, you can use:\r\n\r\n```python\r\nExpression(subquery, OP.EQ, 0)\r\n```\r\n\r\nInstead of `subquery == 0`." ]

[]

[]

[]

[]

[]

[ "I don't think using arrays with jsonb is a sensible thing for anyone to do, since json has a native list type already. Going to pass on this.", "whether you think it is sensible is immaterial, postgresql allows it. and clearly some people have usecases for it.\r\n" ]

[]

[]

[ "```sql\r\nSELECT\r\n COALESCE(\"t1\".\"guid\", \"t2\".\"guid\") AS \"guid\",\r\n COALESCE(\"t1\".\"remedy_group\", ?) AS \"name\",\r\n \"t3\".\"id\",\r\n COUNT(\"t2\".\"host_id\") AS \"count\",\r\n JSON_GROUP_ARRAY(\"t2\".\"host_id\") AS \"host_ids\" \r\nFROM \"vulnerability\" AS \"t2\" \r\nINNER JOIN \"plugin\" AS \"t3\" ON (\"t2\".\"plugin_id\" = \"t3\".\"id\") \r\nINNER JOIN \"query\" AS \"t4\" ON (\"t2\".\"query_id\" = \"t4\".\"id\") \r\nINNER JOIN \"host\" AS \"t5\" ON (\"t2\".\"host_id\" = \"t5\".\"ip_address\") \r\nLEFT OUTER JOIN \"team\" AS \"t1\" ON (\"t1\".\"name\" = (\r\n SELECT \"t1\".\"name\" FROM \"team\" AS \"t1\" \r\n WHERE (\r\n (\"t1\".\"name\" = TRIM(json_extract(\"t5\".\"tags\", ?))) OR \r\n (\"t1\".\"remedy_group\" = TRIM(json_extract(\"t5\".\"tags\", ?)))) LIMIT ?\r\n)) \r\nWHERE ((\r\n (\"t2\".\"remediation_group_id\" = ?) AND \r\n (\"t4\".\"process\" IN (?, ?))) AND\r\n (\"t5\".\"state\" != ?)) \r\nGROUP BY \r\n COALESCE(\"t1\".\"guid\", \"t2\".\"guid\"), \r\n COALESCE(\"t1\".\"remedy_group\", ?), \r\n \"t3\".\"id\" \r\nORDER BY COALESCE(\"t1\".\"guid\", \"t2\".\"guid\"), COALESCE(\"t1\".\"remedy_group\", ?), \"t3\".\"id\"\r\n```", "Does one of those models have a primary key that is a foreign-key to a different table?\r\n\r\nIs there any way you can provide a *minimal* way to reproduce this issue? At the very least subtract from this example until you can isolate the minimal query that reproduces the problem?", ">I am guessing I somehow have a Vulnerability with a host_id set to a value that doesn't have a corresponding PK in the Host table\r\n\r\nHow would this happen? The whole thing with referential integrity is that this should not occur.", "Going through the stack trace, I'll show you my thoughts:\r\n\r\nWe're checking if an instance belongs to a set/dict, so we need its hash, which consists of the class and primary-key value:\r\n\r\n```\r\n File \"/var/task/peewee.py\", line 6483, in __hash__\r\n return hash((self.__class__, self._pk))\r\n```\r\n\r\nThe `_pk` accessor is a property that gets the value of the primary-key field. Note that it uses `primary_key.safe_name`. When the primary-key is *also* a foreign-key, this accessor will the be \"object_id_name\", which allows us to access the raw value of the foreign-key, rather than potentially issuing a query to resolve the foreign-key to an instance.\r\n\r\n```\r\n File \"/var/task/peewee.py\", line 6374, in get_id\r\n return getattr(self, self._meta.primary_key.safe_name)\r\n```\r\n\r\nIt looks like you've got a composite primary-key...Why do people do this?!\r\n\r\n```\r\n File \"/var/task/peewee.py\", line 5382, in __get__\r\n for field_name in self.field_names])\r\n```\r\n\r\nOne part of the composite pk is also a foreign-key?\r\n\r\n```\r\n File \"/var/task/peewee.py\", line 4332, in __get__\r\n return self.get_rel_instance(instance)\r\n```\r\n\r\nMissing the part we need:\r\n\r\n```\r\n File \"/var/task/peewee.py\", line 4327, in get_rel_instance\r\n raise self.rel_model.DoesNotExist\r\n```", "In your composite primary-key that also contains a foreign-key, try changing the foreign-key part to be the \"safe-name\" of the FK rather than the FK field itself:\r\n\r\n```python\r\n\r\n# Change this:\r\nprimary_key = CompositeKey('host', 'other_field')\r\n\r\n# To this:\r\nprimary_key = CompositeKey('host_id', 'other_field')\r\n```\r\n\r\nTry that out and let me know if it fixes the problem and works.\r\n\r\n>using composite primary keys ever\r\n\r\nActive record ORMs do not work well with composite pks. Try using a regular autoincrement / uuid in the future and just put a unique constraint on the columns you need to guarantee are unique. You'll have a much better time.", "@brandond - can you please take a look at my latest comment and provide additional info?", "I have been able to reproduce the issue by adding the following code to tests/models.py:\r\n\r\n```python\r\nclass Neighbourhood(TestModel):\r\n name = CharField()\r\n city = ForeignKeyField(City)\r\n class Meta:\r\n primary_key = CompositeKey('name', 'city')\r\n\r\nclass TestCompositePKwithFK(ModelTestCase):\r\n @requires_models(City, Neighbourhood)\r\n def test_join_query(self):\r\n city = City.create(name='city')\r\n neighbourhood = Neighbourhood.create(name='n1',city=city)\r\n\r\n query = (Neighbourhood\r\n .select(\r\n Neighbourhood.name,\r\n City.name\r\n )\r\n .join(City).where(\r\n Neighbourhood.name == 'n1'\r\n ) )\r\n \r\n res = query.get()\r\n self.assertEqual(res.name,'n1')\r\n self.assertEqual(res.city.name, 'city')\r\n```\r\nI am not sure of what you mean with the safe-name of the FK. Replacing \"city\" by \"city_id\" in the CompositeKey declaration causes a KeyError at database creation time", "You're probably going to hate me for this, but here's a subsection of the model code. I have the business logic in a subclass of RemediationGroupBase, so self.vulnerabilities hits the backref to the Vulnerability model which does indeed have a composite pk.\r\n\r\n```python\r\n\r\nclass RemediationGroupBase(ModelBase):\r\n \"\"\"Peewee model class representing persistent data associated with a Tenable asset group\"\"\"\r\n id = IntegerField(verbose_name='Group ID', primary_key=True)\r\n name = CharField(verbose_name='Group Name')\r\n guid = CharField(verbose_name='Template GUID')\r\n mid_tier = CharField(verbose_name='Remedy Mid-Tier')\r\n process = CharField(verbose_name='Process')\r\n\r\n class Meta:\r\n without_rowid = True\r\n table_name = 'remediation_group'\r\n\r\nclass Vulnerability(ModelBase):\r\n \"\"\"Peewee model class representing a single Vulnerability finding\"\"\"\r\n last_seen = DateTimeField(verbose_name='Last Seen Date')\r\n first_seen = DateTimeField(verbose_name='First Seen Date')\r\n plugin_text = CompressedField(verbose_name='Plugin Text', compression_level=9)\r\n netbios_name = CharField(verbose_name='NetBIOS Name')\r\n mac_address = CharField(verbose_name='MAC Address')\r\n repository = CharField(verbose_name='Repository')\r\n port = IntegerField(verbose_name='Port')\r\n dns_name = CharField(verbose_name='DNS Name')\r\n protocol = CharField(verbose_name='Protocol')\r\n host = ForeignKeyField(verbose_name='Host', model=Host, backref='vulnerabilities')\r\n plugin = ForeignKeyField(verbose_name='Plugin', model=Plugin, backref='vulnerabilities')\r\n remediation_group = ForeignKeyField(verbose_name='Remediation Group', model=RemediationGroupBase, backref='vulnerabilities')\r\n query = ForeignKeyField(verbose_name='Query ID', model=Query, backref='vulnerabilities')\r\n guid = CharField(verbose_name='Query Template GUID')\r\n patched = BooleanField(verbose_name='Patched', default=False)\r\n\r\n class Meta:\r\n without_rowid = True\r\n primary_key = CompositeKey('host', 'port', 'protocol', 'plugin', 'first_seen')\r\n```\r\n\r\nI'm using a composite PK because I'm bulk-loading denormalized data from a 3rd party API and just use insert().on_conflict_replace() to deduplicate rows.\r\n\r\nI'll try replacing 'host' with 'host_id', etc in the CompositeKey and see if that makes it happier.", "As @Nurbel mentioned, using the safe name causes a KeyError on table creation:\r\n\r\n```\r\n File \"/home/ec2-user/.local/lib/python2.7/site-packages/ticketlib/models.py\", line 178, in <module>\r\n Vulnerability.create_table(safe=True)\r\n File \"/home/ec2-user/.local/lib/python2.7/site-packages/peewee.py\", line 6529, in create_table\r\n cls._schema.create_all(safe, **options)\r\n File \"/home/ec2-user/.local/lib/python2.7/site-packages/peewee.py\", line 5679, in create_all\r\n self.create_table(safe, **table_options)\r\n File \"/home/ec2-user/.local/lib/python2.7/site-packages/peewee.py\", line 5534, in create_table\r\n self.database.execute(self._create_table(safe=safe, **options))\r\n File \"/home/ec2-user/.local/lib/python2.7/site-packages/peewee.py\", line 5492, in _create_table\r\n for field_name in meta.primary_key.field_names]\r\nKeyError: 'plugin_id'\r\n```", "Thanks for the info - I'll get to the bottom of this.", "I'll give that change a try, but the tests have all failed?", "I'll fix the tests, thanks." ]

[]

[]

[ "Ehhh, man that's a really quite badly-broken schema. Not using constraints is one thing, but using constraints and then having them be extremely broken is not really something I intend to support.\r\n\r\nIf you need a workaround, just use pwiz' \"-t\" option to explicitly specify the list of un-broken tables, and then enter in the others by hand." ]

[]

[]

[ "Peewee is an active record ORM, so you would need to `save()` any instances you modify." ]

[]

[]

[ "We don't currently support inspecting constraints besides \"NOT NULL\" and an implied \"UNIQUE\"." ]

[]

[]

[ "Currently we don't support detection of special index-types." ]

[]

[]

[ "Thanks!" ]

[]

[]

[]

[]

[]

[ "Thanks, I've merged your patch." ]

[]

[]

[]

[]

[]

[ "Merged patch for UUID array.\r\n\r\nAn array of json doesn't make sense to me, since json supports lists as a fundamental data type." ]

[]

[]

[ "This is not your personal \"help\" message board. Use stackoverflow if you need help. Also you contacted me directly via my website in addition to posting here. Please don't spam.\r\n\r\nAs I said in my email response to you, your data is fucked. You're storing lat/lon in a string field like `[1.234, 2.345]`. Just process your data and separate them out into two separate numeric columns, and your life will be easier *plus* your queries will execute dramatically faster.", "`the_string_expression.cast('numeric')` should do it, by the way." ]

[]

[]

[ "Verified on Postgres 12 as well. Thanks for the report.", "Fixed. Thanks again for the report!" ]

[]

[]

[ "usermessage is not user? I think you have problems with your schema. Peewee is not fundamentally broken, if that's what you're suggesting.\r\n\r\nTry stackoverflow for questions like these in the future.", "I am not suggesting peewee is broken. I am just trying to figure what is going on here. \r\nI being bugged by these issue for quite a while and I have no clue how to figure this out. Maybe I need to fix my schema. But I don't where to start. Is this really because I have a table called user?", "Your schema is messed up is what I'm trying to suggest. Why would the usermessage's id be the same as the user's id? There's not even a foreign-key to the user table anywhere in your schema.\r\n\r\n>because I have a table called user\r\n\r\nNo.", "I dumped the database and re-imported it with an ID 1 instead of 9 (after editing the sql file). I don't know if it is a good idea. Maybe it's a patchy solution. \r\nBy saying the schema is messed up you mean that the data was corrupt? Could it be because I made some changes without peewee?\r\nAlternatively, by saying `Your schema is messed up` do you mean I need to change my models in Python?\r\nI am sorry if these are trivial questions for you. This project is the first project I did with peewee so it's not trivial for me. \r\n" ]

[]

[]

[ "UNION ALL is provided because it is needed for writing recursive queries, so the omission was somewhat intentional.", "And UNION is required for writing other recursive queries. I added another small example to further illustrate the difference [here](https://github.com/aconz2/peewee/blob/feature/cte-union/tests/models.py#L2829-L2839) \r\n\r\n", "Thanks, I've merged an equivalent patch.", "Awesome, much appreciated" ]

[]

[]

[ "When you have a primary key that is not autogenerated, you need to specify `force_insert=True` when saving.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#id4\r\n\r\nHere's my advice: don't use composite keys. Just use the standard autoinc primary key and use a multi-column unique constraint. You'll have a **much** better time.\r\n\r\nPeewee doesn't support foreign keys to composite primary keys, either, which sometimes trips people up.\r\n\r\nLastly, Google before you post, because this is heavily traveled ground" ]

[]

[]

[ "In this minimal test, using an auto-increment primary key, Peewee is returning the PK of the modified row:\r\n\r\n```python\r\n\r\ndb = SqliteDatabase(':memory:')\r\n# Or use postgres\r\n# db = PostgresqlDatabase('peewee_test')\r\n\r\nclass Register(Model):\r\n key = TextField(unique=True)\r\n value = IntegerField()\r\n class Meta:\r\n database = db\r\n\r\ndb.create_tables([Register])\r\n\r\nRegister.create(key='k0', value=0)\r\niq = (Register\r\n .insert(key='k1', value=1)\r\n .on_conflict(conflict_target=[Register.key],\r\n update={Register.value: Register.value + 1}))\r\n\r\nprint(iq.execute())\r\nprint(iq.execute())\r\n\r\nfor r in Register.select():\r\n print(r.key, r.value)\r\n```\r\n\r\nPrints the following for both Sqlite and Postgres:\r\n\r\n```\r\n2\r\n2\r\nk0 0\r\nk1 2\r\n```\r\n\r\nWhich is what I'd expect.", "On same schema:\r\n\r\n```python\r\ndata = {'k0':0, 'k1':1, 'k2':2}\r\n\r\nfor k, v in data.items():\r\n iq = (Register\r\n .insert(key=k, value=v)\r\n .on_conflict_ignore()\r\n .execute())\r\n print(f'on_conflict_ignore change = {iq}')\r\n\r\nprint('table contains:')\r\nfor r in Register.select():\r\n print(r.key, r.value)\r\n\r\nfor k, v in data.items():\r\n iq = (Register\r\n .insert(key=k, value=v)\r\n .on_conflict(conflict_target=[Register.key],\r\n update={Register.value: Register.value + 1})\r\n .execute())\r\n print(f'on_conflict_update change = {iq}')\r\n\r\nprint('table contains:')\r\nfor r in Register.select():\r\n print(r.key, r.value)\r\n```\r\n\r\noutput:\r\n```\r\non_conflict_ignore change = 1\r\non_conflict_ignore change = 2\r\non_conflict_ignore change = 3\r\ntable contains:\r\nk0 0\r\nk1 1\r\nk2 2\r\non_conflict_update change = 3\r\non_conflict_update change = 3\r\non_conflict_update change = 3\r\ntable contains:\r\nk0 1\r\nk1 2\r\nk2 3\r\n```\r\nAll rows was changed. But return of `insert.on_conflict(update = ...).execute()` are alway 3 (`change = 3`). ", "Sqlite is reporting the last insert rowid (3). These examples are not triggering the rows-modified branch, but the last-insert-rowid branch.", "Sorry, I don't understand. How to get a sign that UPDATE has been done? In my case, it doesn’t matter if the return is the number of rows changed as stated in the `.update` documentation, or the PK of the modified row as you said above.", "You mean how to differentiate between inserting a new row and updating an existing one?", "Yes. In my case, tens of thousands of rows are regularly loaded into the table. And need to check if any rows have been updated. This is the trigger for executing a following program code.", "You'll have to experiment with it -- as it is, I believe even if peewee returned you the `rows_affected`, it would still just be the total number of rows you insert/update.", "That is, Peewee hasn't and haven't expect support for returning count_updated or last_modified_rowid for the `.on_conflict(update=)` method. It returns only the rowid of the last execution of insert. While [`Model.update()` returns](http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.update) the number of rows changed. Do I understand correctly?", "There's no such thing as a last-modified rowid in Sqlite. Sqlite has last inserted id, and rows affected." ]

[]

[]

[ "Can you share your desired SQL?", "Possibly there's some quirk in Postgresql's query grammar that requires the \"ON true\" clause. That's rather annoying that it's so particular about it -- but for now I'll suggest using `SQL('true')` until I can look into this a bit more.", "The desired SQL would be \r\n\r\n```\r\nWITH \"sample\" AS (\r\n SELECT \"t1\".\"pk\", \"t1\".\"ra\", \"t1\".\"dec\" FROM \"sky\" AS \"t1\" WHERE (\"t1\".\"pk\" > 200000)) \r\nSELECT \"sample\".\"pk\", \"t2\".\"pk\" FROM \"sample\" LEFT JOIN LATERAL (\r\n SELECT \"sample\".\"pk\" FROM \"sky\" AS \"t3\" WHERE ((\"t3\".\"pk\" IN (SELECT * FROM \"sample\")) AND q3c_join(\"sample\".\"ra\", \"sample\".\"dec\", \"t3\".\"ra\", \"t3\".\"dec\", 0.0016666666666666668)) ORDER BY q3c_dist(\"sample\".\"ra\", \"sample\".\"dec\", \"t3\".\"ra\", \"t3\".\"dec\") ASC LIMIT 1 OFFSET 1) \r\nAS \"t2\" ON true WHERE (\"t2\".\"pk\" IS NULL)\r\n```\r\n\r\nThe only think that doesn't seem to be output is the `ON true`.\r\n\r\nI agree that using `SQL('true')` is better than the `'true'` string and it fixes the problem for me. ", "Ahhh, I think I know what the issue is!\r\n\r\nThis was only fixed recently, in 8829c948 -- which will automatically add the \"on true\" expression whenever you use a lateral join. So you might try upgrading to 3.13 or newer." ]

[]

[]

[ "It's pretty simple - check out: https://github.com/coleifer/flask-peewee/blob/master/flask_peewee/rest.py#L419 for an example of how flask-peewee's REST module handles it.\r\n\r\nYou could also write something recursive. To get the relations, just look at the `model._meta.refs` dict, which maps field instances to related models.\r\n\r\nUntested:\r\n\r\n```python\r\n\r\naccum = [obj]\r\nwhile accum:\r\n curr = accum.pop()\r\n curr.save()\r\n for fk in curr._meta.refs:\r\n rel_obj = getattr(curr, fk.name, None)\r\n if rel_obj is not None:\r\n accum.append(rel_obj)\r\n```", "It looks like this does successfully save all the objects, but it doesn't seem to properly save the foreign key relations in the database. Do you know why that is?", "You probably aren't setting things properly, I have no idea - check your code." ]

[]

[]

[ "If a field is optional, use `null=True`. It will default to an empty (NULL) value." ]

[]

[]

[ "I'm not sure what to tell you, but I've added a (passing) unit-test which shows that this is working correctly in my test setup. If you can provide me a minimal failing test-case I will re-examine, but I think the problem is not with Peewee." ]

[]

[]

[ "The tables *are* created, but since this multi-threaded, their creation may be deferred for a moment.\r\n\r\nFor example:\r\n\r\n```python\r\n\r\ndb = SqliteQueueDatabase(None)\r\n\r\nclass Reg(Model):\r\n key = TextField()\r\n value = IntegerField()\r\n class Meta:\r\n database = db\r\n\r\ndb.init('foo.db')\r\ndb.start()\r\ndb.connect()\r\ndb.create_tables([Reg])\r\n\r\nprint(db.database)\r\nprint(db.get_tables())\r\n```\r\n\r\nThe above code may print:\r\n\r\n```\r\nfoo.db\r\n[]\r\n```\r\n\r\nWhich indicates that the tables aren't created immediately (though they *are* created as soon as the running thread switches). It seems you have forgotten, maybe, that python is single-threaded?\r\n\r\nTo force a context-switch, you can introduce a tiny sleep(), which will switch contexts and then show you the expected output:\r\n\r\n```python\r\n\r\nprint(db.database)\r\nimport time; time.sleep(0.01)\r\nprint(db.get_tables())\r\n```\r\n\r\nThis prints the expected:\r\n\r\n```\r\nfoo.db\r\n['reg']\r\n```", "I think it does not work because the parent's thread is a QThread.\r\nI also tried those snippets (just before the `time.sleep()` trick) without luck:\r\n\r\n```python\r\nfrom PyQt5.QtCore import QCoreApplication\r\nQCoreApplication.processEvents()\r\n```\r\n```python\r\nfrom PyQt5.QtCore import QTimer\r\ntimer = QTimer()\r\ntimer.timeout.connect(lambda: None)\r\ntimer.start(100)\r\n```\r\n\r\nDo you know some workaround?", "how other resolve this question?\r\n\r\nimport time; time.sleep(0.01)\r\n\r\n\r\n\r\n", "this is my code:\r\n\r\nit is ok, `sleep()` is primary code.\r\n\r\n```python\r\n# -*- coding: utf-8 -*-\r\nimport time\r\n\r\nfrom peewee import TextField, AutoField, Model\r\nfrom playhouse.sqliteq import SqliteQueueDatabase\r\n\r\ndb = SqliteQueueDatabase(database='database.db')\r\n\r\n\r\nclass UserModel(Model):\r\n id = AutoField()\r\n name = TextField()\r\n\r\n class Meta:\r\n database = db\r\n\r\n table_name = 'tb_user'\r\n\r\n\r\n# cerate\r\ndb.create_tables([UserModel])\r\n\r\n# wait\r\ntime.sleep(0.01)\r\n\r\n# query\r\nrow = UserModel.select('id').where(\r\n UserModel.id, '=', 1\r\n).get_or_none()\r\n\r\nprint(row)\r\n# None\r\n\r\n```", "You could try using a barrier or an event. See https://docs.python.org/3/library/threading.html" ]

[]

[]

[ "The method you're describing is an acceptable way of handling this. I'm going to pass on implementing a fix right now, but may reconsider it later.", "Actual fix is now in: fe84246980d0b68290db9566b40dad446eefd600", "That's awesome! Thanks for the quick response (and implementing the feature!)." ]

[]

[]

[]

[]

[]

[ "You need a couple things. It seems postgres *requires* the additional parentheses around the function invocation -- which is annoying but workable.\r\n\r\n```python\r\n\r\nfrom peewee import EnclosedNodeList\r\nfrom playhouse.postgres_ext import ObjectSlice\r\n\r\n# Function invocation - nothing weird here.\r\nf = fn.string_to_array(Page.url, '/')\r\n\r\n# Wrap function invocation in additional parentheses.\r\nfp = EnclosedNodeList([f])\r\n\r\n# Indexing operation. Postgres uses 1-based indexes, so 1->2.\r\n# This addition happens in Peewee to allow Python code to emulate\r\n# python's 0-based indexing.\r\nitem = ObjectSlice(fp, [1])\r\n\r\nquery = Page.select(item.alias('url_part'))\r\n```" ]

[]

[]

[ "@coleifer Please check it. I got this behavior again on Peewee 3.13.3, Python 3.8.2 (tags/v3.8.2:7b3ab59, Feb 25 2020, 23:03:10) [MSC v.1916 64 bit (AMD64)] on win32.", "The regression test is passing fine for me. If you add a failing test, I will look into this again.", "```python\r\nfrom peewee import CharField, ForeignKeyField, Model, SqliteDatabase\r\n\r\ndatabase = SqliteDatabase(\":memory:\")\r\n\r\n\r\nclass A(Model):\r\n class Meta:\r\n database = database\r\n only_save_dirty = True\r\n some_str = CharField()\r\n\r\n\r\nclass B(Model):\r\n class Meta:\r\n database = database\r\n only_save_dirty = True\r\n another_str = CharField()\r\n a_instance = ForeignKeyField(model=A)\r\n\r\n\r\nif __name__ == \"__main__\":\r\n database.create_tables(models=[A, B])\r\n a = A.create(some_str='s1')\r\n B.create(another_str='s2', a_instance=a)\r\n b1 = B.select().where(B.another_str == 's2').execute()[0]\r\n print(f\"Without `prefetch`, dirty fields: {b1.dirty_fields}\")\r\n b2 = B.select().where(B.another_str == 's2').prefetch(A)[0]\r\n print(f\"With `prefetch`, dirty fields: {b2.dirty_fields}\")\r\n\r\n```\r\n\r\n", "OP DELIVERS. Thank you!", "Hey - I think I see the problem. There's absolutely no reason to use `prefetch` when going from a child-model to a parent-model, as SQL already handles that. Just do:\r\n\r\n```python\r\n\r\nquery = B.select(B, A).join(A).where(B.another_str == 's2')\r\n```" ]

[]

[]

[ "Paste the full traceback.", "Oh, I see - you're using `Decimal` instead of `DecimalField`. That's likely the issue.", "That's mistake in the code here. In my file it is correct.", "Then paste the full traceback??", "```\r\nTraceback (most recent call last):\r\n File \"tmp.py\", line 22, in <module>\r\n for stuff in Post.select('date', 'user', 'number1'):\r\n File \"/home/rizhiy/anaconda3/envs/data/lib/python3.7/site-packages/peewee.py\", line 4287, in next\r\n self.cursor_wrapper.iterate()\r\n File \"/home/rizhiy/anaconda3/envs/data/lib/python3.7/site-packages/peewee.py\", line 4203, in iterate\r\n self.initialize() # Lazy initialization.\r\n File \"/home/rizhiy/anaconda3/envs/data/lib/python3.7/site-packages/peewee.py\", line 7251, in _initialize_columns\r\n node = raw_node.unwrap()\r\nAttributeError: 'str' object has no attribute 'unwrap'\r\n```", "You need to read the docs. It's nowhere indicated that you pass string field-names into the select() method. You use the field instances themselves.\r\n\r\n```python\r\nPost.select(Post.date, Post.number1, ...)\r\n```\r\n\r\nAlso selecting Post.user will just grab the user_id." ]

[]

[]

[ "You're going to have a really bad time inheriting foreign-keys. It just doesn't work well.\r\n\r\nFurthermore, composite primary-keys are not well-supported, e.g. Peewee doesn't support foreign-keys to models with composite PKs.\r\n\r\nAlso, having different tables for various \"post\" types is almost guaranteed to be a mistake. If you ever want to combine the results you're forced to do unions and then you will be fighting to get the data you need for each type.\r\n\r\nPlay to the strengths of your database and your tools and use a single table with multiple columns (post_type, text, e.g.). It won't waste space. You know what they say about premature optimization, right?\r\n\r\nDo not use a composite PK (really). Just use an auto-incrementing integer or a UUID if you must. You can add a multi-column unique index on anything you need to constrain." ]

[]

[]

[ "I would strongly advise against trying to use a composite primary-key for this, as Peewee provides much better support for scalar primary-keys (integers, uuids, etc). Many things will be harder for you if you switch to a composite primary-key - specifically creating foreign-keys to your \"Person\" table. Peewee **does not support FKs to models with composite PKs**.\r\n\r\nIf you are just trying to enforce the uniqueness of first/last, then create a multi-column UNIQUE index:\r\n\r\n```python\r\n# Specify the table, column names, and whether the index should be\r\n# UNIQUE or not.\r\nmigrate(\r\n # Create a unique index on the first and last name fields:\r\n migrator.add_index('person', ('first', 'last'), True),\r\n)\r\n```\r\n\r\nIf you insist on making your life harder, though, you can consult the Postgresql documentation for instructions on dropping a primary-key and creating a new multi-column PK, as creating/dropping PKs is not supported by the migrations library." ]

[]

[]

[ "Got it working with the `fn` hook into the underlying functions." ]

[]

[]

[ "You can specify a custom field type, e.g.\r\n\r\n```python\r\nclass MediumTextField(TextField):\r\n field_type = 'MEDIUMTEXT'\r\n```\r\n\r\nAnd just use that if the db is mysql.\r\n\r\nAlternatively, you can configure MySQL to treat all textfields as MEDIUMTEXT if you wish:\r\n\r\n```python\r\nMySQLDatabase.field_types['TEXT'] = 'MEDIUMTEXT'\r\n```", "I think something like this is what I was looking for\r\n\r\n```\r\nclass UnknownField(object):\r\n def __init__(self, *_, **__): pass\r\n```\r\n\r\nthank you" ]

[]

[]

[ "Fixed." ]

[]

[]

[]

[]

[]

[ "Don't alias the good or supplier name in query2. The aliases are confusing you. Query2 returns rows but the repr is empty (none) because of the way you aliases the good name.", "I strongly suggest you check out the docs on relationships and joins:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/relationships.html", "@coleifer Thanks all for you help, i made a mistake and not use the relationship\r\n```\r\n query3 = (Goods.select(\r\n Goods.name.alias('g_name'), Supplier.name.alias('s_name')\r\n ).join(Supplier).where(Goods.name.contains('am')).order_by(Goods.name).limit(10))\r\n for item in query3:\r\n print(f'{item.g_name:>15}:{item.supplier.s_name}')\r\n```\r\n\r\n```\r\nAmaranth Leaves:Joshua\r\nAmaranth Leaves:Georgeann\r\nAmaranth Leaves:Londa\r\nAmaranth Leaves:Lee\r\n Bamboo Shoots:Hubert\r\n Bamboo Shoots:Seymour\r\n Bamboo Shoots:Delmar\r\n Bamboo Shoots:Buster\r\n Bamboo Shoots:Mirella\r\n Edamame:Delmy\r\n```" ]

[]

[]

[ "Can you share the generated SQL for your query? I tried to replicate a minimal example and the generated SQL contains qualified names that would seem to resolve any ambiguity.\r\n\r\nAlso, what version of Peewee are you using?", "generated SQL:\r\n`\r\n('UPDATE \"user_data\".\"user_file_rows\" SET \"location_ids\" = \"parent_ids\" FROM \"r_data\".\"location\" AS \"t1\" WHERE ((st_intersects(\"geom\", \"geom\") AND (\"fileid_id\" = %s)) AND (\"location_level_id\" = %s))', ['6f3697c3-****', 4])\r\n`\r\n\r\nI use peewee 3.6.4\r\nThanks", "Upgrade to a newer version - that should resolve the problem with the SQL generation.", "I upgraded version. It works.\r\n\r\nThanks" ]

[]

[]

[ "The docs are very clear, you cannot use python \"or\", \"and\" or \"not\" to combine expressions.\r\n\r\nRewrite\r\n\r\n```python\r\nPerson.fname != EXCLUDED.fname or Person.lname != EXCLUDED.lname\r\n```\r\n\r\nAs\r\n\r\n```python\r\n(Person.fname != EXCLUDED.fname) | (Person.lname != EXCLUDED.lname)\r\n```", "Thank you! This worked for me. I am struggling to find the documentation on this. Could you point me to the link if you have it handy, please?", "https://docs.peewee-orm.com/en/latest/peewee/query_operators.html#" ]

[]

[]

[ "Please edit your issue to format your code and I will reopen." ]

[]

[]

[ "MySQL does not support \"IF NOT EXISTS\" for indexes for some reason.\r\n\r\nSo what peewee does when you're using MySQL is to first check if the table exists -- and if it does -- then it's a no-op. So I think something weird may be going on in your setup.", "Ok, I think I found the problem.\r\n\r\nI capitalized the first letter in the name of the table. But on mysql workbench it showed as all lower letters. I did some tests:\r\ntable._meta.table_name returned 'Show'\r\ndb.table_exists(\"Show\") returned false \r\ndb.table_exists(\"show\") returned true\r\n\r\nIf I capitalize the first letter of the name of the table, it doesn't detect the table exists and does the create table operation.\r\n\r\nIf i don't capitalize, everything works as expected.", "I think by default mysql uses case insensitive tables in windows, which I'm running.\r\n\r\nPeewee should, somehow, read this behaviour from the mysql lower_case_table_names variable." ]

[]

[]

[ ">I want to get SQL output\r\n\r\nI don't know what this means? The above function will query the database and return the count of rows in the select query.", "You can use `.scalar()` to obtain the result of a scalar aggregate query.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/querying.html#retrieving-scalar-values\r\n\r\nPlease note that the issue tracker is not for \"how do I...\" questions. Post those on stackoverflow or ask in the #peewee IRC channel or mailing list. This is for tracking issues with the software." ]

[]

[]

[ "This is more appropriate for stack-overflow, as the issue tracker is used for tracking issues with the library." ]

[]

[]

[ ">What I get now:\r\n\r\nThat is *not* returned by executing a `select()` query. That is metadata on the model instance. By default, issuing a `select()` will return a cursor that yields model instances for each row of the result set.\r\n\r\nMy guess is that you want something like `.dicts()`, which should give you exactly what you want. Just modify your query:\r\n\r\n```python\r\n\r\nquery = MyModel.select()\r\nfor obj in query:\r\n # obj is a MyModel instance.\r\n ...\r\n\r\n# This is probably what you want:\r\nfor row in query.dicts():\r\n # row is a dict of just the field data.\r\n ...\r\n```\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/querying.html#retrieving-row-tuples-dictionaries-namedtuples", "Yes! That was the thing I've thought to do. All is good now, thanks! :)" ]

[]

[]

[ "Yes, `pwiz` is intended to provide a reasonable best-effort at converting the schema into the db into models, but it is not 100% perfect. As the docs say, it's purpose is to produce some basic skeleton code that should handle correct column types and foreign-keys. Things like constraints across columns with arbitrary SQL functions are not introspected currently.\r\n\r\nThat being said, constraints are not enforced on the Python side at all -- so the fact that peewee models may not reflect the constraint will not have any impact on the actual constraint that exists in the database.", "Ok, I agree. But I think in that case it would be better, if pwiz just do nothing (the non-text field is assigned unique), because it’s easy to overlook and it’s confusing later when you look at the models while develop. I understand that this can be difficult to fix. This is just a wish =)", "Thanks, I will look into it some more.", "So unfortunately this is a limitation of the data returned by postgresql when introspecting the set of indexes on a table. Peewee uses a rather complex query to ask postgres for metadata about the index, which includes an aggregation of the columns used in that index. Because the unique comprises a column and a function, our query only returns the column which was matched.\r\n\r\nFor now I don't think we can do much better and this will just have to be a known limitation.\r\n\r\nAlternatives might be to try and parse the index sql to extract the columns, but in that case we still wouldn't be likely to get an accurate reflection of the actual schema since we'd also have to capture the functions being applied." ]

[]

[]

[ "Yes:\r\n\r\n```python\r\n# let's say we want to update two rows.\r\nvl = ValuesList([\r\n (1, 'huey-x'),\r\n (2, 'zaizee-x')], columns=['id', 'username'], alias='vl')\r\nquery = (User\r\n .update({'username': vl.c.username})\r\n .from_(vl)\r\n .where(User.id == vl.c.id))\r\n```", "Also you can look at the tests:\r\n\r\nhttps://github.com/coleifer/peewee/blob/fc342ddcfda268a27e40a8178982ddf747de80a8/tests/models.py#L4120-L4162" ]

[]

[]

[ "Just append to a list and use `reduce` to combine the list elements (expressions).", "https://stackoverflow.com/questions/22238194/python-peewee-dynamically-or-clauses?r=SearchResults", "That still has the same issue with an empty clauses array. you need to have one element for this to work.", "```python\r\nclauses = [\r\n (User.username == 'something'),\r\n (User.something == 'another thing'),\r\n ...\r\n]\r\nquery = User.select()\r\nif clauses:\r\n query = query.where(reduce(operator.or_, clauses))\r\n```" ]

[]

[]

[ "I'm going to pass on this implementation. I think a more correct approach would be to create a standalone connection-state manager for asyncio usage. This could be provided by a mixin that overrides the `Database.__init__()` method and assigns compatible values to `_state` and `_lock` (also note that this patch does not handle `_lock`).", "I see. Would you be willing to accept a mixin like that as part of Peewee?\r\n\r\nAbout `_lock`, its job is to bock _all_ the other threads that want to use the same lock. In an async framework, Peewee interactions would/should run in a threadpool with `run_in_executor`, and `threading.lock` would still be blocking any other thread that tries to use the same lock. So it would behave the same and achieve the same.\r\n\r\nIn contrast, `contextvars` are needed because the same connection data would be used in more than one thread, so it needs to be shareable. And the same thread could end up handling different connections, so they need to be dependent on their async context, not the thread.", "> Would you be willing to accept a mixin like that as part of Peewee?\r\n\r\nI'm not sure yet. Peewee isn't async internally; doesn't use async idioms, doesn't use async drivers, etc. At the same this is a legit issue for people trying to use Peewee with asyncio. That said, the solution is 3.7+ only, which I guess is a very small number of users.\r\n\r\nHowever I think most people who want to use Peewee with asyncio just use [peewee-async](https://github.com/05bit/peewee-async). So I'm not sure if there's an actual need for this change.\r\n\r\nAt the end of the day I'm always in favor of playing to pythons dynamism and using gevent, which just works.", "Get it. Thanks for the feedback. I'll document it accordingly in FastAPI.", "Just chiming in: I have a FastAPI+Peewee project going, mostly because I enjoy each project's simplicity. I didn't choose FastAPI because it's async, I choose it because it was a quick and easy way to build a project.\r\n\r\nI think some better support between the two projects would be worthwhile, even if Peewee will never be async-ready. FastAPI is asyncio-based, but is _so much more than just for async_, so I'd urge you to consider the mixin." ]

[]

[]

[ "Looks like a breaking change made here: https://github.com/coleifer/peewee/commit/36f5b4a0fef0bd236f25bf99f92f74852f219103", "For now try removing the keyword (lock_type) and just pass the string 'immediate'. I will put together a fix, in any case.", "I'm tagging a new release once the build passes. Thanks for reporting this so quickly.", "https://github.com/coleifer/peewee/releases/tag/3.13.1", "Thank you for the fast update" ]

[]

[]

[ "Thanks for reporting, this is now fixed in master." ]

[]

[]

[ "It's pretty simple, I added a test-case showing how to do it:\r\n\r\n```python\r\nclass Order(TestModel):\r\n name = TextField()\r\n\r\n @hybrid_property\r\n def quantity(self):\r\n return sum([item.qt for item in self.items])\r\n\r\n @quantity.expression\r\n def quantity(cls):\r\n return fn.SUM(Item.qt).alias('quantity')\r\n\r\nclass Item(TestModel):\r\n order = ForeignKeyField(Order, backref='items')\r\n qt = IntegerField()\r\n\r\ndata = (\r\n ('a', (4, 3, 2, 1)),\r\n ('b', (1000, 300, 30, 7)),\r\n ('c', ()))\r\nfor name, qts in data:\r\n o = Order.create(name=name)\r\n for qt in qts:\r\n Item.create(order=o, qt=qt)\r\n\r\nquery = Order.select().order_by(Order.name)\r\n# NOTE: this loop issues an additional query for each order in the loop\r\n# because it has to gather up all the order's items and count the quantities.\r\nself.assertEqual([o.quantity for o in query], [10, 1337, 0])\r\n\r\nquery = (Order\r\n .select(Order.name, Order.quantity.alias('sql_qt'))\r\n .join(Item, JOIN.LEFT_OUTER)\r\n .group_by(Order.name)\r\n .order_by(Order.quantity.desc()))\r\nself.assertEqual([o.sql_qt for o in query], [None, 1337, 10])\r\n```\r\n\r\nYou probably omitted the join / group-by when using it in a query.\r\n\r\nNote in case it is not obvious, but resolving the property on an order instance will issue a query to grab all that order's items and sum them in python. **It's hugely inefficient and should never be done.**", "Thanks for the (very!) quick answer on this, this solves perfectly my need!\r\n\r\nIt would probably be a nice addition to http://docs.peewee-orm.com/en/latest/peewee/hacks.html (or any better place in the doc), as it deserves more emphasis from within the doc, in my opinion!\r\n\r\nThanks!", "Glad to help. This is not something I would encourage simply because it can imply additional queries in a non-obvious way." ]

[]

[]

[ "Hey, there's some cool stuff in here. I'll look to maybe integrate some of this. Can you tell me more about some of the changes I'm looking at? I understand the reasoning for certain of them, but others aren't clear exactly what the intent is.", "* e5ad248db24210e62a2a3829ea78627202aa0d3d\r\n* 99921b9b3d8444eec1daf58d4ce06b6210e3aefd\r\n* 8829c9483fef222e844a092c7720c8e5f6ee1a07" ]

[]

[]

[ "You have *got* to be kidding me, this is absolute garbage. It is incredibly easy to build your own SQLite, which the default Python driver should pick up.\r\n\r\nThis should contain all the information you might need:\r\n\r\nhttp://charlesleifer.com/blog/compiling-sqlite-for-use-with-python-applications/", "Not seeing a single thing about Windows on there, plus specifying a single dependency with pre-built binaries would make cross-platform distribution a lot easier but thanks for the quick response, I guess?", "Sorry - I don't know the first thing about how to do this on Windows.", "Okay, I'll investigate what I need to do for that and how to bundle it up with my app. Given that I'll struggle to then get a Windows build working with gitlab CI, would implementing my own backend be the best way forward should I want to use that other lib? Or is some sort of monkey patch possible to get the existing one working?", "You can look at the apsw playhouse extension for an example, since it looks like supersqlite is a wrapper on apsw." ]

[]

[]

[ "Peewee should only be traversing the graph of tables related by foreign-key, so my guess is that you have some weird stuff going on in your foreign-key inheritance because Peewee will not traverse subclasses blindly. If you can provide a minimal example showing a bug I will reopen.", "A minimal example is no problem. \r\nAs you will see the class `Child` is not created as a table and is only used as a template to be inherited from.\r\n\r\n```\r\n# docker run --name postgres -e POSTGRES_DB=postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_USER=postgres -d -p 5432:5432 postgres\r\n\r\nfrom peewee import *\r\n\r\npg_db = PostgresqlDatabase('postgres', user='postgres', password='postgres',\r\n host='localhost', port=5432)\r\n\r\nclass Parent(Model):\r\n name = CharField()\r\n class Meta:\r\n database = pg_db\r\n\r\nclass Child(Model):\r\n parent = ForeignKeyField(Parent)\r\n class Meta:\r\n database = pg_db\r\n\r\nclass Son(Child):\r\n boys_name = CharField()\r\n\r\nclass Daughter(Child):\r\n girls_name = CharField()\r\n\r\nif __name__ == '__main__':\r\n pg_db.create_tables([Parent, Son, Daughter])\r\n parent = Parent.create(name='dad')\r\n Son.create(boys_name='jim', parent=parent)\r\n Daughter.create(girls_name='jane', parent=parent)\r\n parent.delete_instance(recursive=True)\r\n```", "Oh, I see what you mean - thank you, you are correct this does produce an error due to the missing Child table. Unfortunately, this is not something I am planning to fix, as inheritance + foreign-keys has always been rather fraught territory. Peewee models maintain an in-memory graph of their relations and there is no way to differentiate between a model that is used as a simple \"base-class\" only.\r\n\r\nMy recommendation would be to put the foreign-keys on the base-classes *OR* declare your foreign-keys such that they specify the appropriate on_delete/on_update behavior and then avoid using recursive delete-instance.\r\n\r\n```python\r\nparent = ForeignKeyField(Parent, on_delete='cascade')\r\n```\r\n\r\nPutting FKs on base-classes is also problematic because of the way backrefs are set-up. It's truly better to just put them where they live." ]

[]

[]

[ "Peewee uses a heuristic for function calls when the first argument is a field, where peewee applies that field's conversion method to the value returned by the database. This usually works, but you've found a case where it is problematic. To avoid coercing the function output, specify `coerce=False`:\r\n\r\n```python\r\n# Note you don't need TestModel.flag == True\r\nfn.IF(TestModel.flag, 'hello', 'goodbye', coerce=False)\r\n```", "Confirmed. Thanks!" ]

[]

[]

[ "Peewee returns a parameterized query, a 2-tuple of SQL string and parameters. This is to save people doing crazy stuff and getting SQL injection vulnerabilities. The driver accepts this 2-tuple and does the right thing.", "What about for DB API (PEP-249) v2.0 drivers? How can I tell peewee to not add double quotes on everything? \r\nex:\r\nfrom: SELECT \"t1\".\"item1\", \"t1\".\"item2\", \"t1\".\"item3\" FROM \"trex_inventory_recipe_material\" AS t1\r\nto: SELECT t1.item1, t1.item2, t1.item3 FROM trex_inventory_recipe_material AS t1", "Why would you want to do that? Lots of times people unwittingly (or intentionally) use reserved words for column-names, e.g. \"count\". Peewee adds quotes to ensure that identifiers are always treated as-such.", "I'm using Impyla which is fully DB API v2.0 compiant. And the HiveServer2 (Hive) gives an error when it sees double quoted column-names.", "On your database class, just set the quote attribute to be an empty string.\r\n\r\n```python\r\n\r\nclass HiveDatabase(...)\r\n quote = ''\r\n```\r\n\r\nDoes that address the issue?", "No change - using peewee 2.9.0\r\nI'm still getting double quotes when doing a select() on the Model,\r\n\r\n<class 'model.dbo.item_table.ItemTable'> SELECT \"t1\".\"rname\", \"t1\".\"mrole\", \"t1\".\"rmaterial\" FROM \"db1\".\"item_table\" AS t1 []\r\n", ">peewee 2.9.0\r\n\r\nThat's a very old version, from March 2017. For peewee 3.0, I think you would actually set `quote = ('', '')` instead of empty string, but since you're on such an old version I'm not sure what to advise.", "Thanks @coleifer - appreciate it. Thanks for pointing me in the right path - using `quote = ''`\r\nAlso, you reminded me that I forgot to change the version on the documentation. I was looking at the \"latest\". Older versions (like 2.9.0) use `quote_char = ''` \r\nYup; I will be upgrading it and fix any breaks along the way. Thank you!" ]

[]

[]

[ "Sorry, 3.12.0 seems to work, closing. I was using 3.10", "OK, It's not fixed. Actually it randomly happens each time you restart the flask server.", "I think the reason is in function of peewee.ModelSelect.filter().\r\ntarget code is:\r\n```python\r\n dq_joins = set()\r\n while q:\r\n curr = q.popleft()\r\n if not isinstance(curr, Expression):\r\n continue\r\n for side, piece in (('lhs', curr.lhs), ('rhs', curr.rhs)):\r\n if isinstance(piece, DQ):\r\n query, joins = self.convert_dict_to_node(piece.query)\r\n dq_joins.update(joins)\r\n```\r\n\r\nI can't understand why you use set() to define dq_joins? if use list(), this error will disappear.", "Thanks for the analysis. Yeah, it looks like the use of `set` is causing problems with the ordering of the joins. I will take a look!", "Fixed.", "Thanks! peewee has the lowest open-issue/star ratio in all the repositories I have seen on GitHub. ^_^" ]

[]

[]

[ "I'm sorry, this is not something I can help with. No code, extremely vague description, no information about where things are stuck.\r\n\r\nYou might just make sure that before you fork new processes you are creating a new database connection, as an open connection in the parent-process might get inherited by the child process which could be buggy / problematic.", "filter.py:\r\n\r\n```\r\nfrom mwapilib import get_qual_samples, get_mwapi_session,\\\r\n get_page_revs_with_quals,get_user_info, chunkify, main_header,\\\r\n talk_header, user_header, get_page_edits_from_db\r\nfrom revscoring.utilities.util import dump_observation, read_observations\r\nfrom concurrent.futures import ThreadPoolExecutor\r\n\r\ndef get_all_page_revs(labelings, workers = 5):\r\n all_edits = pd.DataFrame([], columns = main_header)\r\n executor = ThreadPoolExecutor(max_workers=workers)\r\n session = get_mwapi_session()\r\n partial_get_page_revs = partial(get_page_revs_with_quals, session)\r\n #edits_from_db = get_page_edits_from_db(labelings)\r\n for edits in executor.map(partial_get_page_revs, labelings):\r\n for labeling in labelings:\r\n edits = partial_get_page_revs(labeling)\r\n all_edits = all_edits.append(edits, sort = False)\r\n pdb.set_trace()\r\n return all_edits\r\n```\r\n\r\n\r\nmwapilib:\r\n\r\n\r\n```\r\nimport mwapi\r\nimport traceback\r\nimport numpy as np\r\nimport sys\r\nimport pdb\r\nfrom itertools import islice\r\nimport pandas as pd\r\nimport random\r\nimport mwreverts.api\r\nfrom mw.lib import title as mwtitle\r\nimport traceback\r\nfrom multiprocessing import Pool\r\nfrom models import Page, Quality, Revision, User\r\nfrom models import database as db\r\nfrom functools import partial\r\nfrom revscoring.utilities.util import dump_observation, read_observations\r\nimport peewee\r\nimport json\r\nimport re\r\n\r\ndef get_page_edits(session, labeling):\r\n pageid = labeling['pageid']\r\n page_revs_arr = []\r\n # First, try to look for the pageid in the database\r\n page_present = Revision.select().where(Revision.rev_page ==\r\n pageid).count()\r\n page_present = 0\r\n #if False:\r\n if page_present > 0:\r\n page_revs = []\r\n # get results\r\n revs = (Page\r\n .select(Page, Revision)\r\n .join(Revision, on=(Page.page_id==Revision.rev_page).alias('rev'))\r\n .where(Page.page_id == pageid\r\n ))\r\n for page in revs:\r\n rev = page.rev\r\n page_revs.append([rev.rev_id, rev.rev_page, rev.rev_comment,\r\n rev.rev_user, rev.rev_user_text, rev.rev_timestamp,\r\n rev.rev_minor_edit, rev.rev_len,\r\n rev.rev_sha1, rev.rev_quality, page.page_title])\r\n\r\n return pd.DataFrame(page_revs, columns = main_header)\r\n\r\n elif page_present == 0:\r\n page_revs = []\r\n doc = session.get(\r\n action='query', prop='revisions', formatversion=2,\r\n pageids = pageid, rvprop=['ids', 'timestamp', 'user', 'size', 'comment',\r\n 'sha1', 'flags', 'userid'],\r\n continuation=True, rvlimit=500, rvslots='main', rvdir='newer')\r\n title = ''\r\n for result in doc:\r\n pages = result['query']['pages']\r\n for page in pages:\r\n if 'revisions' not in page:\r\n continue\r\n for rev in page['revisions']:\r\n revid = rev['revid']\r\n pageid = page['pageid']\r\n title = mwtitle.normalize(page['title'])\r\n ts = pd.Timestamp(rev.get('timestamp', ''))\r\n\r\n rev = (\r\n revid,\r\n pageid,\r\n rev.get('comment', ''),\r\n rev.get('userid'),\r\n rev.get('user'),\r\n rev.get('timestamp', ''),\r\n 1 if rev.get('minor', False) else 0,\r\n rev.get('size', 0),\r\n rev.get('sha1', '')\r\n )\r\n page_revs.append(rev)\r\n\r\n talk_id = labeling['talk_page_id']\r\n talk_edits = get_page_qualities(session, talk_id)\r\n page_revs_with_quals = []\r\n for rev in page_revs:\r\n ts = rev[5]\r\n t_filter = talk_edits['rev_timestamp'] < ts\r\n rev_new = list(rev)\r\n rev_new[5] = pd.Timestamp(ts).strftime('%Y%m%d%H%M%S')\r\n try:\r\n max_ts = talk_edits.where(t_filter)['rev_timestamp'].idxmax()\r\n quals.append(talk_edits.loc[max_ts, 'quality'])\r\n rev_new = list(rev)\r\n rev_new[5] = pd.Timestamp(ts).strftime('%Y%m%d%H%M%S')\r\n page_revs_with_quals.append(tuple(rev_new) + (class_map[quals[-1]],))\r\n except:\r\n sys.stderr.write('#')\r\n sys.stderr.flush()\r\n page_revs_with_quals.append(tuple(rev_new) + (0,))\r\n quals.append('non-def')\r\n\r\n Revision.insert_many(page_revs_with_quals,fields=['rev_id', 'rev_page',\r\n 'rev_comment', 'rev_user', 'rev_user_text', 'rev_timestamp',\r\n 'rev_minor_edit', 'rev_len', 'rev_sha1' ,'rev_quality']).execute()\r\n Page.insert(page_id = pageid, page_namespace = 0, page_title =\r\n title).execute()\r\n edits = pd.DataFrame([rev+(title,) for rev in page_revs_with_quals], columns = main_header)\r\n return edits\r\n```\r\n\r\nthe filter class creates multiple processes and calls the get_page_revs from mwapilib.py in each of them. The get_page_revs function uses the Page, and Revision db models to query existing data and inserts new data after fetching from api.\r\n\r\nThe processes are getting stuck in deadlock in the get_page_edits function.\r\n\r\nModels:\r\n```\r\nfrom peewee import *\r\n\r\ndatabase = MySQLDatabase(....})\r\n\r\nclass UnknownField(object):\r\n def __init__(self, *_, **__): pass\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = database\r\n\r\nclass Page(BaseModel):\r\n page_id = IntegerField()\r\n page_namespace = IntegerField()\r\n page_title = CharField()\r\n\r\n class Meta:\r\n table_name = 'page'\r\n primary_key = False\r\n\r\nclass Revision(BaseModel):\r\n rev_comment = CharField()\r\n rev_id = IntegerField()\r\n rev_len = IntegerField(null=True)\r\n rev_minor_edit = IntegerField()\r\n rev_page = IntegerField()\r\n rev_quality = IntegerField()\r\n rev_sha1 = CharField(null=True)\r\n rev_timestamp = CharField()\r\n rev_user = IntegerField()\r\n rev_user_text = CharField(null=True)\r\n\r\n class Meta:\r\n table_name = 'revision'\r\n primary_key = False\r\n```", "It's called \"**Thread**PoolExecutor\" - meaning threads, not processes.", "> The processes are getting stuck in deadlock in the get_page_edits function.\r\n\r\nWhere exactly?", "@codez266 you fell into a trap that many Python noobs are falling into.\r\nThreads in Python are not CPU threads, but rather execution threads internal to the CPython interpreter. All your threads are running on a single CPU. Running alot of threads with IO will\r\ncause a lot of context switching and slow execution. \r\nConsider re-designing your software in such way that you delegate the heavy processing to the database, not the Python client. If you have no other choice, consider using \r\n```\r\nfrom multiprocessing import Pool\r\n```\r\nBut this comes with some caveats. " ]

[]

[]

[ "It seems you included two versions in the issue title -- are you indicating this is a regression?", "At any rate -- when you are using a left outer join, all rows from the left-hand table (Tweet) are included, along with any matching from the right-hand (User). This means you can have Tweet without a User.\r\n\r\nWhen you manually patch a related object onto a user-defined attribute, currently peewee does not set the join attribute when there is no data/related-object to set.\r\n\r\nYou can work around this for now by just using the regular `user` attr, or you can use `hasattr(tweet, 'author')` / `getattr(tweet, 'author', None)` instead.", "> It seems you included two versions in the issue title -- are you indicating this is a regression?\r\n\r\nI have seen this behaviour with both versions. \r\n\r\nyes, it's, in a way, a regression. With version 2.x (it used to be defined with an **alias** of the join condition) it was working. The value of the property was None, eg, the test was `twee.author is None`", "This is probably worth documenting as I was expecting a null result. (Thinking about it, I suspect the null result would be rather difficult to implement -- so docs would be great)" ]

[]

[]

[ "It's right there in the docs.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#table-names\r\n\r\n> If you wish to implement your own naming convention\r\n\r\nIt has example code." ]

[]

[]

[]