Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "Thank you!" ]

[]

[]

[ "Try to use Pycharm. ", "pycharm works fine, thank you!" ]

[]

[]

[ "Sure, you can use `Value(123456)`:\r\n\r\n```python\r\n\r\n# If prefix is a string literal:\r\nquery = SomeTable.select().where(Value('123456').startswith('someprefix'))\r\n\r\n# If prefix is a column on the table:\r\nquery = SomeTable.select().where(Value('123456').startswith(SomeTable.prefix))\r\n```", "Oh really good, I did not found it in the documentation\r\nThanks very much @coleifer, you made my day :+1: \r\n\r\nthis is only in 3.4.0 version, right ?", "The `Value` type was added in 3.0. Prior to 3.x you may be able to use `Param` instead." ]

[]

[]

[ "I tried moving the `with db.atomic():` inside the `for group in tqdm(groups):` loop which is how I had written it in `sqlite` and the progress bar said that it would take 6 hours to complete versus 2 minutes in `sqlite`\r\n\r\n```python\r\n with h5py.File(dataset, 'r') as infile:\r\n groups = list(infile)\r\n for group in tqdm(groups): # Around 50k iterations\r\n data = []\r\n for i, myval in enumerate(np.array(infile[group]['myval'])):\r\n data.append((group, 'c{0:06d}'.format(i), myval, False, False))\r\n with db.atomic():\r\n Data.insert_many(data, fields=fields).execute()\r\n```", "This is how the code looks like in `sqlite`\r\n\r\n```python\r\nc.execute('CREATE TABLE workunits (wuID INTEGER PRIMARY KEY, name TEXT DEFAULT NULL)')\r\nconn.commit()\r\nc.execute('''CREATE TABLE data (x1 TEXT NOT NULL, \r\n x2 TEXT NOT NULL, \r\n x3 INTEGER, \r\n x4 REAL DEFAULT NULL, \r\n x5 REAL DEFAULT NULL, \r\n x6 INTEGER DEFAULT NULL, \r\n x7 INTEGER DEFAULT NULL,\r\n FOREIGN KEY(x3) REFERENCES workunits(wuID),\r\n PRIMARY KEY(x1, x2)\r\n )''')\r\nconn.commit()\r\nconn.close()\r\n\r\nwith h5py.File(dataset, 'r') as infile:\r\n groups = list(infile)\r\n for group in tqdm(groups):\r\n rdata = [(group, 'c{0:06d}'.format(i), 0, val, 0, 0) for i, val in enumerate(np.array(infile[group]['val']))]\r\n c.executemany(\"INSERT INTO data VALUES (?, ?, NULL, ?, ?, ?, ?)\", rdata)\r\n```", "I have a feeling that the answer is: \"use NoSQL\" :grin: ", "My personal answer will never be to use NoSQL! Peewee can handle this, but it does impose some overhead. Here are the docs on ideas for speeding-up bulk inserts:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/querying.html#bulk-inserts\r\n\r\n[Your comment](https://github.com/coleifer/peewee/issues/1615#issuecomment-392557450), in which you use a transaction and insert_many() looks good but you may be hitting practical limits with SQLite's ability to parameterize the data. Peewee also may be getting in the way by ensuring/validating data-types before building up the query. You can always profile the code to see what's going on.\r\n\r\nUsing `executemany()` with a sqlite3 cursor is just fine, too. Peewee database objects have a `cursor()` method with exposes a DB-API cursor. So this should work:\r\n\r\n```python\r\ndb = pw.SqliteDatabase(...)\r\ndb.create_tables([WorkUnit, Data])\r\ncursor = db.cursor()\r\n\r\nwith h5py.File(dataset, 'r') as infile:\r\n groups = list(infile)\r\n for group in tqdm(groups):\r\n rdata = [(group, 'c{0:06d}'.format(i), 0, val, 0, 0) for i, val in enumerate(np.array(infile[group]['val']))]\r\n cursor.executemany(\"INSERT INTO data VALUES (?, ?, NULL, ?, ?, ?, ?)\", rdata)\r\n```\r\n\r\nLastly, you can try batching the inserts:\r\n\r\n```python\r\n with h5py.File(dataset, 'r') as infile:\r\n groups = list(infile)\r\n for group in tqdm(groups): # Around 50k iterations\r\n data = []\r\n for i, myval in enumerate(np.array(infile[group]['myval'])):\r\n data.append((group, 'c{0:06d}'.format(i), myval, False, False))\r\n\r\n with db.atomic():\r\n for i in range(0, len(data), 100): # INSERT 100 rows at-a-time\r\n Data.insert_many(data[i:i+100], fields=fields).execute()\r\n```", "Great! Thanks for the input :) I will give it a try tomorrow.", "So I tried the peewee cursor\r\n```python\r\ncursor = db.cursor()\r\ncursor.executemany(\"INSERT INTO data VALUES (?, ?, NULL, ?, ?, ?, ?)\", rdata)\r\n```\r\nversus the sqlite cursor\r\n```python\r\nconn = sqlite3.connect(dbpath)\r\nc = conn.cursor()\r\nc.executemany(\"INSERT INTO data VALUES (?, ?, NULL, ?, ?, ?, ?)\", rdata)\r\n```\r\nand the first one is still orders of magnitude slower. I don't know what the cause is since I can't profile very easily on the machine I'm currently on but in any case it seems I'll just mix'n'match between peewee and sqlite3 for the moment.\r\n", "That's very strange, since the first one is literally the same as the second. It *may* have something to do with the way Peewee sets up the connection autocommit... you can try wrapping it in a transaction and seeing if that has any effect:\r\n\r\n```python\r\nwith db.atomic():\r\n cursor.executemany(...)\r\n```" ]

[]

[]

[ "Yes, this is the intended behavior. That group by looks sketchy as hell since you're selecting columns that aren't included in the group by...granted, that probably works fine for SQLite and MySQL. Anyways!\r\n\r\n`model_to_dict` probably isn't going to work correctly for what you're trying to do without some gymnastics. It's probably much easier to just do something like:\r\n\r\n```python\r\naccum = []\r\nfor user_obj in result:\r\n user_dict = model_to_dict(user_obj, recurse=False)\r\n user_dict['latest_event'] = model_to_dict(user_obj.event, recurse=False)\r\n```", "Thanks, the group_by clause had the wrong content (fixed now).\r\n\r\nDoes your solution still apply or is there some automated way now? Or is there a better way for the query so that there is an automated way?", "The solution I gave is probably the easiest way to achieve what you want. Events is a backref from the perspective of the user object, so peewee treats it as a list. Since you only need the one event per user, just use the approach I suggested.", "The given example works as expected. Thank you very much for your help. I think I just expected too much automatism after reading the manual. :)\r\n\r\nSome minor stuff: I think you forgot to add the user_dict to the accum list in your example." ]

[]

[]

[ "Thanks, I've fixed this in 8a95426 and added a test and updated docs. I appreciate you taking the time to report this issue." ]

[]

[]

[ "So in examining / digging through your tests I see your documentation isn't accurate. Looks like it needs to be updated.\r\n\r\nhttps://github.com/coleifer/peewee/blob/49c162d5939bb52627c1e6a1687e722b8bf83ec9/tests/database.py#L398\r\n\r\n\r\ndocumented\r\n<img width=\"702\" alt=\"screen shot 2018-05-24 at 8 22 18 pm\" src=\"https://user-images.githubusercontent.com/6467508/40524715-02f652c0-5f91-11e8-9f98-fa47bc38ebec.png\">\r\n\r\n\r\nactually...\r\n<img width=\"341\" alt=\"screen shot 2018-05-24 at 8 24 11 pm\" src=\"https://user-images.githubusercontent.com/6467508/40524726-16597fe0-5f91-11e8-85a6-a36e768d2cc3.png\">\r\n", "Thank you, I've fixed this so that the implementation matches the docs (i.e., you pass the table name)." ]

[]

[]

[ "Ok so the GET if I just do that fails!! But why? I can run this query by hand in psql ...\r\nThere are other fields in the table, here they are, but this record does exist, wht this value for code.\r\n\r\n\r\ndoing a select explicitly\r\n('SELECT \"t1\".\"code\", \"t1\".\"allstars\", \"t1\".\"average_resale_factor\", \"t1\".\"away_losses\", \"t1\".\"away_pitcher_rating\", \"t1\".\"away_points\", \"t1\".\"away_wins\", \"t1\".\"canceled\", \"t1\".\"count_resales\", \"t1\".\"count_scans\", \"t1\".\"count_tickets\", \"t1\".\"days_since_last_game\", \"t1\".\"days_until_next_game\", \"t1\".\"division\", \"t1\".\"family\", \"t1\".\"games_left\", \"t1\".\"home_losses\", \"t1\".\"home_pitcher_rating\", \"t1\".\"home_points\", \"t1\".\"home_win_percent\", \"t1\".\"home_win_record\", \"t1\".\"home_wins\", \"t1\".\"kd_playing\", \"t1\".\"national_holiday\", \"t1\".\"national_tv\", \"t1\".\"nearest_storm\", \"t1\".\"opponent_id\", \"t1\".\"precipitation\", \"t1\".\"precipitation_intensity\", \"t1\".\"prediction_override\", \"t1\".\"promotional\", \"t1\".\"religious_holiday\", \"t1\".\"rw_playing\", \"t1\".\"star_multiplier\", \"t1\".\"team_id\", \"t1\".\"team_score\", \"t1\".\"temperature\", \"t1\".\"time\", \"t1\".\"meta_sold_seats_number\", \"t1\".\"meta_available_seats_number\", \"t1\".\"meta_total_num_seats_stadium\", \"t1\".\"meta_available_seats_total_cost\" FROM \"game\" AS \"t1\" WHERE (\"t1\".\"code\" = %s) LIMIT %s OFFSET %s', [u'LR091816', 1, 0])\r\nwere not able to get it\r\nTraceback (most recent call last):\r\n File \"/home/anon/Desktop/ra/precast-master/precast_ingest_util.py\", line 139, in create_or_increment\r\n foo = model.get(model.code == 'LR091816')\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 5311, in get\r\n return sq.get()\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 5705, in get\r\n return clone.execute()[0]\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 1522, in inner\r\n return method(self, database, *args, **kwargs)\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 1593, in execute\r\n return self._execute(database)\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 1747, in _execute\r\n cursor = database.execute(self)\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 2590, in execute\r\n return self.execute_sql(sql, params, commit=commit)\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 2584, in execute_sql\r\n self.commit()\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 2377, in __exit__\r\n reraise(new_type, new_type(*exc_args), traceback)\r\n File \"/home/anon/miniconda2/lib/python2.7/site-packages/peewee.py\", line 2577, in execute_sql\r\n cursor.execute(sql, params or ())\r\nInternalError: current transaction is aborted, commands ignored until end of transaction block\r\n\r\n", "in psql on this db \r\nthe following returns a record\r\n\r\n SELECT \"t1\".\"code\", \"t1\".\"allstars\", \"t1\".\"average_resale_factor\", \"t1\".\"away_losses\", \"t1\".\"away_pitcher_rating\", \"t1\".\"away_points\", \"t1\".\"away_wins\", \"t1\".\"canceled\", \"t1\".\"count_resales\", \"t1\".\"count_scans\", \"t1\".\"count_tickets\", \"t1\".\"days_since_last_game\", \"t1\".\"days_until_next_game\", \"t1\".\"division\", \"t1\".\"family\", \"t1\".\"games_left\", \"t1\".\"home_losses\", \"t1\".\"home_pitcher_rating\", \"t1\".\"home_points\", \"t1\".\"home_win_percent\", \"t1\".\"home_win_record\", \"t1\".\"home_wins\", \"t1\".\"kd_playing\", \"t1\".\"national_holiday\", \"t1\".\"national_tv\", \"t1\".\"nearest_storm\", \"t1\".\"opponent_id\", \"t1\".\"precipitation\", \"t1\".\"precipitation_intensity\", \"t1\".\"prediction_override\", \"t1\".\"promotional\", \"t1\".\"religious_holiday\", \"t1\".\"rw_playing\", \"t1\".\"star_multiplier\", \"t1\".\"team_id\", \"t1\".\"team_score\", \"t1\".\"temperature\", \"t1\".\"time\", \"t1\".\"meta_sold_seats_number\", \"t1\".\"meta_available_seats_number\", \"t1\".\"meta_total_num_seats_stadium\", \"t1\".\"meta_available_seats_total_cost\" FROM \"game\" AS \"t1\" WHERE (\"t1\".\"code\" = 'LR091816') LIMIT 1 OFFSET 0;\r\n", "Ok so a pee wee sleet for this code works fine, but the get fails?\r\n\r\n try:\r\n print(\"doing a select explicitly fails\")\r\n Game.select()\r\n print(\"get one code explicit select\") # this works\r\n foo = Game.select().where(Game.code == 'LR091816')\r\n print(foo)\r\n \r\n print(\"get one code explicit get\") # ths fails !!\r\n foo = Game.get(Game.code == 'LR091816')\r\n print(foo)\r\n \r\n print(\"doing a get with passed in model explicitly fails\")\r\n foo = model.get(model.code == 'LR091816')\r\n print(\"\\nlets try getting it with model.get and passing in dic\")\r\n z = model.get(**kwargs)\r\n print(z)\r\n except:\r\n print(\"were not able to get it\")\r\n traceback.print_exc() \r\n exit()\r\n\r\n\r\nConsider\r\nget one code explicit select\r\n<peewee.ModelSelect object at 0x7f3544100890>\r\nget one code explicit get\r\n('SELECT \"t1\".\"code\", \"t1\".\"allstars\", \"t1\".\"average_resale_factor\", \"t1\".\"away_losses\", \"t1\".\"away_pitcher_rating\", \"t1\".\"away_points\", \"t1\".\"away_wins\", \"t1\".\"canceled\", \"t1\".\"count_resales\", \"t1\".\"count_scans\", \"t1\".\"count_tickets\", \"t1\".\"days_since_last_game\", \"t1\".\"days_until_next_game\", \"t1\".\"division\", \"t1\".\"family\", \"t1\".\"games_left\", \"t1\".\"home_losses\", \"t1\".\"home_pitcher_rating\", \"t1\".\"home_points\", \"t1\".\"home_win_percent\", \"t1\".\"home_win_record\", \"t1\".\"home_wins\", \"t1\".\"kd_playing\", \"t1\".\"national_holiday\", \"t1\".\"national_tv\", \"t1\".\"nearest_storm\", \"t1\".\"opponent_id\", \"t1\".\"precipitation\", \"t1\".\"precipitation_intensity\", \"t1\".\"prediction_override\", \"t1\".\"promotional\", \"t1\".\"religious_holiday\", \"t1\".\"rw_playing\", \"t1\".\"star_multiplier\", \"t1\".\"team_id\", \"t1\".\"team_score\", \"t1\".\"temperature\", \"t1\".\"time\", \"t1\".\"meta_sold_seats_number\", \"t1\".\"meta_available_seats_number\", \"t1\".\"meta_total_num_seats_stadium\", \"t1\".\"meta_available_seats_total_cost\" FROM \"game\" AS \"t1\" WHERE (\"t1\".\"code\" = %s) LIMIT %s OFFSET %s', [u'LR091816', 1, 0])\r\nwere not able to get it\r\n", "perhaps get is not an API I should use, was only doing it for testing\r\nwill go back to select and see if I can implement get_or_create with explicity calls", "i pass in my model (table name) as a variable to a def\r\nalong with kwargs\r\n\r\nI tried\r\nmodel.select().where(**kwargs)\r\n\r\nbut that does not expand kwargs into\r\ncode == 'foo'\r\n\r\nhow do I convert my kwargs into a where expr?\r\n", "if I do a simple .create then the records are created\r\n\r\nso it seem that the .get is failing to detect if record is present ?", "AHH \r\n\r\nso when I call get_or_create I am NOT passing in an exression A = B\r\ninstead I have a dictionary A:B, ...\r\nthat I pass in\r\n\r\nDoes the aPI no longer support this? Perhaps it never did?\r\n\r\nHow do I convert from a dictoinary to the expression get_or_create requires?", "I have been passing in a dictionary\r\nusing **dict to get_or_create\r\n\r\nand that hsould have worked ...?\r\n", "oh but the create wants a = while the get wants a ==\r\n\r\nI wonder how that works out internally to peewee", "so the basic first problem is the get_or_create call\r\n\r\nwhy it is finding some \"other\" id other than the id of my the record I want to look at it is just a puzzle (the error). peewee fails on this dupcliate key violation, when it trys to create a new record using an existing id for a record that should never have been looked at/modified in the table!!", "leaving me with the desire to try doing this all by hand to see if it would work ... but not knowing how to write the select (or update) passing in a dicdtionary of values as I don't know how to write the were expression in python from a dictionary/hash.", "Can you clarify exactly what problem you'd like help solving? I'm having a hard time following your comments.", "For what it's worth, `get_or_create` accepts keyword arguments and works on that basis. The `InternalError` you're seeing indicates that something like the following has occurred:\r\n\r\n1. An insert/delete/update triggered an integrity error.\r\n2. You did not explicitly rollback / commit\r\n3. A select was issued subsequent to the integrity error and is failing now.\r\n\r\nThe simplest implementation for get-or-create looks like this:\r\n\r\n```python\r\n\r\n# First try to create it. Rely on an integrity error being raised to determine\r\n# that the object exists.\r\ntry:\r\n with MyModel._meta.database.atomic():\r\n obj = MyModel.create(...)\r\nexcept IntegrityError:\r\n obj = MyModel.get(...)\r\n```\r\n\r\nIf you wish to try and do the select first:\r\n\r\n```python\r\ntry:\r\n obj = MyModel.get(...)\r\nexcept MyModel.DoesNotExist:\r\n try:\r\n with MyModel._meta.database.atomic():\r\n obj = MyModel.create(...)\r\n except IntegrityError:\r\n obj = MyModel.get(...)\r\n```", "Hello,\n\nSure.\n\nGiven a hash/dictionary in python like\nx = {\"a\":1, \"b\":2}\n\nHow can i write a select query in python, given only x as input, where I want to just\nget records that have a == 1 and b == 2\nso the query\nmodel.select().where(x)\nwhich translates into\nmodel.select().where(model.a == 1, model.b == 2)\n\nIf I can do that I can debug what is going on I think.\n\nThanks!\nevan\n\nSent with [ProtonMail](https://protonmail.com) Secure Email.\n\n‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐\nOn May 23, 2018 9:59 AM, Charles Leifer <[email protected]> wrote:\n\n> Can you clarify exactly what problem you'd like help solving? I'm having a hard time following your comments.\n>\n> —\n> You are receiving this because you authored the thread.\n> Reply to this email directly, [view it on GitHub](https://github.com/coleifer/peewee/issues/1611#issuecomment-391357055), or [mute the thread](https://github.com/notifications/unsubscribe-auth/AXFzJr7UYTwcNnd2VKW9qcpDDyTYy3Tvks5t1WskgaJpZM4UKOxE).", "If I can do a select then I would also like to do an update and a create using the same paradigm. Basically write get_or_create by hand. And then see where it crashes in my code .\n\nThanks!\nEvan\n\nSent with [ProtonMail](https://protonmail.com) Secure Email.\n\n‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐\nOn May 23, 2018 12:07 PM, evan <[email protected]> wrote:\n\n> Hello,\n>\n> Sure.\n>\n> Given a hash/dictionary in python like\n> x = {\"a\":1, \"b\":2}\n>\n> How can i write a select query in python, given only x as input, where I want to just\n> get records that have a == 1 and b == 2\n> so the query\n> model.select().where(x)\n> which translates into\n> model.select().where(model.a == 1, model.b == 2)\n>\n> If I can do that I can debug what is going on I think.\n>\n> Thanks!\n> evan\n>\n> Sent with [ProtonMail](https://protonmail.com) Secure Email.\n>\n> ‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐\n> On May 23, 2018 9:59 AM, Charles Leifer <[email protected]> wrote:\n>\n>> Can you clarify exactly what problem you'd like help solving? I'm having a hard time following your comments.\n>>\n>> —\n>> You are receiving this because you authored the thread.\n>> Reply to this email directly, [view it on GitHub](https://github.com/coleifer/peewee/issues/1611#issuecomment-391357055), or [mute the thread](https://github.com/notifications/unsubscribe-auth/AXFzJr7UYTwcNnd2VKW9qcpDDyTYy3Tvks5t1WskgaJpZM4UKOxE).", "If you want to use keyword-arguments for your where clause (which is gross but OK) you can use [filter()](http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.filter). For example:\r\n\r\n```python\r\nclass User(Model):\r\n username = TextField()\r\n\r\nuser_obj = User.filter(username='charlie').get()\r\n\r\n# Or, multiple objects:\r\nusers = User.filter(username__in=['charlie', 'huey', 'mickey'])\r\nfor user in users:\r\n print(user.username)\r\n```\r\n\r\nIt's better to use expressions, though. You can very easily convert a dictionary into the appropriate expressions by using `Model._meta.fields`, which is a mapping of field-name -> field object.\r\n\r\nI think your code is \"crashing\" because of an un-rolled-back integrity error that occurs. You mention you're using Postgres -- how are you instantiating your database?", "I am using Postgres. And have several apps hitting it. I just do a create database x\n\nThere are lots of constraints between my tables. Indeed if a table a was behind not available that would be a problem\n\nBut when I just alone try to get or create these records it fails to work. The records do not get created. However the raw create call will work creating the records.\n\nA select will fail to return the record of done before create.\n\nA get will fail but complain about some other record Id\n\nEvan", "You know that get_or_create and related apis are all covered by thorough tests. If there were something fundamentally broken these tests would fail. My point is that the code works. As to why you're having issues, I don't know but I suspect the problem is not peewee.", "Hello,\n\nOh I am sure that pee wee is not the problem.\n\nI am thinking that perhaps\nI crash somewhere and then postgres is not responding.\n\nDo I need to wrap calls in an atomic or commit/rollback in the event that a call fails?\n\nThe problem is more that I upgraded and have not figured out something that changed. Or I am getting data in a bad order (my current thought).\n\nSo perhaps I do\na get_create or some other sql call - which fails. But do not rollback?\n\nAnd then later do a\nget_or_create which fails be cause postgres is in a bad state?\n\nTrying to come up with some theory ...\n\nEvan\n\nSent with [ProtonMail](https://protonmail.com) Secure Email.\n\n‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐\nOn May 23, 2018 2:01 PM, Charles Leifer <[email protected]> wrote:\n\n> You know that get_or_create and related apis are all covered by thorough tests. If there were something fundamentally broken these tests would fail. My point is that the code works. As to why you're having issues, I don't know but I suspect the problem is not peewee.\n>\n> —\n> You are receiving this because you authored the thread.\n> Reply to this email directly, [view it on GitHub](https://github.com/coleifer/peewee/issues/1611#issuecomment-391442617), or [mute the thread](https://github.com/notifications/unsubscribe-auth/AXFzJo4Wgd3LurhlXNS7ny1Ekiyr9Pjqks5t1aQAgaJpZM4UKOxE).", "Hello,\n\nI have about a dozen very large applications running peewee, and there is no problem. They are all very similar.\n\nIt is just this new app (two of them actually) that is having some issue. So the \"data\" coming in and then my code is the issue. The integrity issue is certainly a great one for me to look at. Just not sure how to find a example of where that happens.\n\nMy code loads lots of csv files, which are all interdependent but noisy - so constraints sometimes do not get satisfied.\n\nIf one of the inserts (or updates) \"fails\" with peewee. do I need to do anything to get postgres (or peewee) to continue to work for the next unrelated insert/update?\n\nEvan\n\nSent with [ProtonMail](https://protonmail.com) Secure Email.\n\n‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐\nOn May 23, 2018 2:22 PM, evan <[email protected]> wrote:\n\n> Hello,\n>\n> Oh I am sure that pee wee is not the problem.\n>\n> I am thinking that perhaps\n> I crash somewhere and then postgres is not responding.\n>\n> Do I need to wrap calls in an atomic or commit/rollback in the event that a call fails?\n>\n> The problem is more that I upgraded and have not figured out something that changed. Or I am getting data in a bad order (my current thought).\n>\n> So perhaps I do\n> a get_create or some other sql call - which fails. But do not rollback?\n>\n> And then later do a\n> get_or_create which fails be cause postgres is in a bad state?\n>\n> Trying to come up with some theory ...\n>\n> Evan\n>\n> Sent with [ProtonMail](https://protonmail.com) Secure Email.\n>\n> ‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐\n> On May 23, 2018 2:01 PM, Charles Leifer <[email protected]> wrote:\n>\n>> You know that get_or_create and related apis are all covered by thorough tests. If there were something fundamentally broken these tests would fail. My point is that the code works. As to why you're having issues, I don't know but I suspect the problem is not peewee.\n>>\n>> —\n>> You are receiving this because you authored the thread.\n>> Reply to this email directly, [view it on GitHub](https://github.com/coleifer/peewee/issues/1611#issuecomment-391442617), or [mute the thread](https://github.com/notifications/unsubscribe-auth/AXFzJo4Wgd3LurhlXNS7ny1Ekiyr9Pjqks5t1aQAgaJpZM4UKOxE).", "> If one of the inserts (or updates) \"fails\" with peewee. do I need to do anything to get postgres (or peewee) to continue to work for the next unrelated insert/update?\r\n\r\nYes, you'd need to rollback. e.g. `db.rollback()`", "I'm going to close this... this issue is out-of-control. If you can create a reproducible *short* script that I can use to reproduce the failure, I'm happy to look into this again.", "Ok" ]

[]

[]

[ "Can you create a minimal test-case I can use to reproduce the issue? I'm unclear from your comment what your model looks like or where the actual error is occurring.", "I don't seem to be able to reproduce this on a simple case so it may have something to do with my DB (Postgresql). For what I can see, the problem is related to the fact that, although the primary key in Plate has a sequence set, when I do the \r\n\r\n```python\r\ndbo, created = Plate.get_or_create(plate_id=1234)\r\n```\r\n\r\nThe resulting object doesnt have a pk\r\n\r\n```python\r\ndbo\r\n<Plate: pk=None, plate_id=1234>\r\n```\r\n\r\nOther tables in the same DB, with primary key sequences set in the same manner return an object with a `pk != None` when initialised with `get_or_create`. I'll keep digging.\r\n\r\n", "Ok, I think I fixed it. In my Models some of the primary keys were set to `BigIntegerField` instead of to `PrimaryKeyField` because the underlying primary key field was set as a big integer in Postgresql. Changing it to `PrimaryKeyField` seems to have solved the issue and I don't see any ill effect.\r\n\r\nWorth noting that the models were generated using pywiz, although the peewee 2 version of it. Also, this used to work fine in peewee 2 so not sure if this is a bug or not.", "Sounds like you got it.\r\n\r\nFor what it's worth, in peewee 3.x, you can use `AutoField` or `BigAutoField` depending on the underlying data-type (serial vs bigserial). `PrimaryKeyField` is provided for backwards-compatibility, but is just an alias for `AutoField`." ]

[]

[]

[ "From the MySQL [update docs](https://dev.mysql.com/doc/refman/8.0/en/update.html):\r\n\r\n> You cannot update a table and select from the same table in a subquery.\r\n\r\nSee also [delete docs](https://dev.mysql.com/doc/refman/8.0/en/delete.html#idm139870165521360).\r\n\r\nThis appears to be a MySQL limitation. You can try to work around it in your code, but for now Peewee does not implement a workaround for this specific issue.", "Hi Charles,\r\n\r\nYeah, I was worried that would be the case.\r\nAny suggestions on how I could tackle this? Any function in the model I could re-implement to make it work? \r\n\r\nThe [fixes suggested on stackoverflow](https://stackoverflow.com/a/44971214/9288624) seem easy enough, but Idon't have enough insight into peewee yet to know where to start.\r\n\r\nThank you for the quick reply by the way!\r\nYour support for this project is outstanding.", "I didn't realize it was possible to even do the above...one would think that the MySQL query engine would be able to rewrite the problematic query as a selection from a derived table. Alas.\r\n\r\nFor starters, peewee `Model` does expose a `dependencies` method, which yields 2-tuples of the form `(query, foreign-key)` and provides access to all dependent objects. You could look into the code there for some ideas on how to resolve dependencies. Another option which may or may-not work is to use a common table expression (requires newer mariadb / mysql 8 if I recall correctly).\r\n\r\nWithout really getting into the nitty-gritty I can't be more specific right now.", "Alright, thank you. Would be fantastic if an official solution would find it's way into Peewee in the future. Meanwhile I will have a closer look into the `dependencies` method. CTEs are no option for me unfortunately (because of the new requirements). If I find a suitable, generic workaround I'll post it here. \r\n", "An alternative might be to simply specify your foreign-keys as \"ON DELETE CASCADE\" and then just delete the parent row (or \"ON DELETE SET NULL\" as the case may be). The ForeignKeyField() accepts \"on_delete\" and \"on_update\" parameters, e.g.\r\n\r\n```python\r\nfk_field = ForeignKeyField(SomeModel, on_delete='CASCADE')\r\n```" ]

[]

[]

[ "That's a nice workaround but I'll see what I can do to offer better support.", "This fix will be in the 3.4.0 release. If you plan to continue using 2.10 then the subclassing solution is totally fine." ]

[]

[]

[ "Peewee supports a regexp operator. Depending on the database you're using, you can utilize the db-specific features to handle case-sensitivity.", "Added support for MySQL and Postgresql. SQLite is going to be trickier and I may not implement it.\r\n\r\nSee: f631f222fe6b0c5cb68de99dede98d03454d3e3f" ]

[]

[]

[ "Since you don't appear to have actual foreign-keys, you'll need to tell peewee how to reconstruct the model graph by providing aliases in your join predicates:\r\n\r\n```python\r\n .join(age, pw.JOIN.LEFT_OUTER, on=(cit.AGE_ID == age.AGE_ID).alias('agecitas'))\r\n .join(per, pw.JOIN.LEFT_OUTER, on=(age.PER_ID == per.PER_ID).alias('sktpersona'))\r\n```\r\n\r\nAlso one look at the tests should have revealed that this logic is tested thoroughly in peewee. Meaning you have a bug in your code rather than a bug in peewee.\r\n\r\nFor that you need to use StackOverflow or you can try `#peewee` on freenode IRC. This is not a troubleshooting support site.", "Ok Thanks, I will ask on StackOverflow", "For what it's worth, I *did* answer your question." ]

[]

[]

[ "That is the purpose of `dirty_fields`. For your use-case I'd suggest putting an interface on-top of your model instance and routing accesses through that. In that way you can track changes." ]

[]

[]

[ "Peewee 3.x removed `aggregate_rows` because it was, in retrospect, a poorly-designed hack. The concept, roughly, was to produce a cartesian product of all the requested data and then de-duplicate it on the Python side. It's slow (because Python), expensive (because amount of bits being xferred) and buggy (because I never trusted it enough to start using it in production).\r\n\r\nFor the trivial use-case it works fine (users and tweets). I should not have included it as a public API, though, and that mistake has been corrected in 3.x.\r\n\r\nI'm not planning to implement any fixes for APIs that were deprecated in 3.x, unfortunately I just don't have either the time or the interest. I'm sorry that this bug is occurring, though, and would be happy to help you come up with an alternate way to implement what you're trying to do.", "We are currently refactoring to use prefetch instead. However, I am struggling a bit to understand how it can replace certain parts of joining, such as ordering. So, for example, if I started with a query like this:\r\n```\r\nrecords = A\\\r\n .select(A, B, C)\\\r\n .join(B, JOIN_LEFT_OUTER)\\\r\n .join(C, JOIN_LEFT_OUTER)\\\r\n .order_by(C.val)\\\r\n .aggregate_rows()\r\n```\r\n\r\nI would end up with a list of A objects ordered by some value in C, which is what I want. \r\n\r\nHow would I do the same with prefetch? If I did this:\r\n\r\n```\r\nrecords = prefetch(A.select(), B, C.select().order_by(C.val))\r\n```\r\n\r\nI don't end up what I want, the list of A objects is ordered by A's primary key. \r\n\r\nI suppose I could order the list in python after I have fetched everything, but the database can do this for me and is more efficient. \r\n\r\nThis can also apply to filtering results, so something like this:\r\n\r\n```\r\nrecords = A\\\r\n .select(A, B, C)\\\r\n .join(B, JOIN_LEFT_OUTER)\\\r\n .join(C, JOIN_LEFT_OUTER)\\\r\n .where(C.val < 100)\\\r\n .aggregate_rows()\r\n```\r\n\r\nIt is the same type of issue. I want a list of A objects filtered by some value from C. Again, I suppose I can filter in python. Or I could select the C objects I want and map it backwards, so like this:\r\n\r\n```\r\nprefetch(C.select().where(C.val < 100), B, A) \r\n```\r\n\r\nBut now I have a list of C objects and have to reverse my logic, which is unintuitive.\r\n\r\nIs there any way to replicate the join behavior with prefetch? It uses subqueries, so I don't see how to do this. Or is there some other way I am not seeing? I am looking in the docs but can't seem to find any examples, so if you can point me to some, that would be appreciated.", "So the thing is, you can actually just write:\r\n\r\n```python\r\nquery = (A\r\n .select(A, B, C)\r\n .join(B, JOIN.LEFT_OUTER)\r\n .join(C, JOIN.LEFT_OUTER)\r\n .order_by(C.val))\r\nfor a in query:\r\n if a.b is None:\r\n # just an a\r\n elif a.b.c is None:\r\n # A and b, but no c\r\n else:\r\n # a b and c\r\n```\r\n\r\nThe only thing is you'll get duplicate a's and b's potentially. All `aggregate_rows()` did was try to \"roll up\" the duplicates, but depending on you use-case you can handle it yourself.", "As far as using `prefetch()`, you can also:\r\n\r\n```python\r\na_s = (A\r\n .select()\r\n .join(B, JOIN.LEFT_OUTER)\r\n .join(C, JOIN.LEFT_OUTER)\r\n .order_by(C.val))\r\nall_together = prefetch(a_s, B, C)\r\n```", "I see where you are going with this. The second answer sets off alarm bells in terms of efficiency as it is now doing multiple joins AND multiple subqueries. We have some more complex scenarios so we will need to profile this.\r\n\r\nAs for the first answer, again, we have some more complex queries then listed here, which could create a lot deeper nested logic. Something we will have to look at.\r\n\r\nI get that the aggregate_rows isn't so efficient, but our workload is generally based on serverless computing. So we have infinite compute resources (so to speak), but the bottleneck is always the database. We try to offload as much as we can from the database, which is why aggregate_rows worked well for us. \r\n\r\nEither way, we have some options to stop using aggregate_rows. Perhaps we would also look into fixing the function to suit our purposes, we shall see.", "Combining something like the first approach, which contains duplicate rows, with [itertools.groupby](https://docs.python.org/2/library/itertools.html#itertools.groupby) should allow you to emulate what aggregate_rows() was doing.", "Just to clarify, you expect the second approach to also have duplicate A records, correct? So with either approach we will need to dedupe.", "`prefetch` won't return duplicates, but it is structured differently.", "prefetch won't, but the first query is a join, which will. I just tried it with my above example and saw it returned two objects even though there is only one A in the database.\r\n\r\nUnless I am missing something?", "If you're comfortable with SQL, I'd suggest running the query with the joins in a sql shell and observing the way the columns are represented (and duplicated).", "I am comfortable SQL, and I did run the query. I understand how the columns are all represented. I guess my comment was that peewee is still returning me duplicate A objects, and I thought that you had indicated that maybe it would not. So I was trying to fish for a solution where I did not have to explicitly deduplicate in this scenario. I would honestly expect peewee to return me duplicate A objects, but thought your response indicated it would not. But maybe I just misunderstood your answer?", "> peewee is still returning me duplicate A objects\r\n\r\nExactly. All `aggregate_rows()` did was to roll up the duplicates and accumulate joined rows as related instances. That's why I suggested using something like `itertools.groupby`.", "For anyone who stumbles upon this, here is how we ultimately solved the issue:\r\n\r\n```\r\na_s = (A\r\n .select()\r\n .join(B, JOIN.LEFT_OUTER)\r\n .join(C, JOIN.LEFT_OUTER)\r\n .order_by(C.val))\r\n .group_by(A.id)\r\nall_together = prefetch(a_s, B, C)\r\n```\r\n\r\nAllows us to order A by joined tables, but we dedupe by grouping on A's primary key. Then we prefetch the other values through subqueries. So no duplicate A objects, and all other fields are prefetched. \r\n\r\nPerformance can still be a concern as you are now joining multiple tables, grouping, and then running subqueries on top of that, so your mileage may vary depending on your situation. " ]

[]

[]

[ "`DoesNotExist` is not an instance but a class:\r\n\r\n```python\r\nisinstance(Model.DoesNotExist, Exception) -- False\r\nissubclass(Model.DoesNotExist, Exception) -- True\r\n```\r\n\r\nYou catch it like this:\r\n\r\n```python\r\ntry:\r\n obj = SomeModel.get(SomeModel.field == 'value')\r\nexcept SomeModel.DoesNotExist:\r\n print('obj with field=value does not exist')\r\n```" ]

[]

[]

[ "I added a test-case that I think is equivalent to your example. It is passing for me: 909b371123a73ea00b7db18bbdb870083286d603\r\n\r\nHere's the test-case code:\r\n\r\n```python\r\n def test_union_with_join(self):\r\n u1, u2 = [User.create(username='u%s' % i) for i in (1, 2)]\r\n for u, ts in ((u1, ('t1', 't2')), (u2, ('t1',))):\r\n for t in ts:\r\n Tweet.create(user=u, content='%s-%s' % (u.username, t))\r\n\r\n q1 = (User\r\n .select(User, Tweet)\r\n .join(Tweet, on=(Tweet.user == User.id).alias('tweet')))\r\n q2 = (User\r\n .select(User, Tweet)\r\n .join(Tweet, on=(Tweet.user == User.id).alias('tweet')))\r\n\r\n with self.assertQueryCount(1):\r\n self.assertEqual(\r\n sorted([(user.username, user.tweet.content) for user in q1]),\r\n [('u1', 'u1-t1'), ('u1', 'u1-t2'), ('u2', 'u2-t1')])\r\n\r\n uq = q1.union_all(q2)\r\n with self.assertQueryCount(1):\r\n result = [(user.username, user.tweet.content) for user in uq]\r\n self.assertEqual(sorted(result), [\r\n ('u1', 'u1-t1'),\r\n ('u1', 'u1-t1'),\r\n ('u1', 'u1-t2'),\r\n ('u1', 'u1-t2'),\r\n ('u2', 'u2-t1'),\r\n ('u2', 'u2-t1'),\r\n ])\r\n```\r\n\r\nAm I missing something?", "Travis-CI build including the above patch: https://travis-ci.org/coleifer/peewee/builds/377071024 (passed)", "Sorry. I feel really stupid for not checking which peewee version I was using. \r\n\r\nI just upgraded to the latest from peewee version 3.2.3 and it works. \r\n\r\nYep...I'm an idiot.", "No need to apologize, this was fixed only recently." ]

[]

[]

[ "Oops, just realized the problem is already fixed in the [latest version](https://github.com/coleifer/peewee/blob/master/playhouse/sqlite_ext.py#L47).\r\n\r\nPlease close the issue. Thanks" ]

[]

[]

[ "Sorry, there's not really any way to identify these kinds of mistakes. The documentation makes it abundantly clear that you're to use `&` and `|`, typically if you do make the mistake of using `and` and `or` you won't repeat it." ]

[]

[]

[ "I try many peewee versions, 3.2.4 is first version that return the values of table1 and 3.2.3 is the latest version that return the value of table2", "The change that was introduced was to avoid overwriting values. You're selecting all columns on `Table1` (including it's status field), so it's expected that the status field would contain the value on Table1.\r\n\r\nTo capture the status field on table 2 there are a number of things you can do:\r\n\r\n* specify an alias for the Table2.status value (e.g. Table2.status.alias('status2'))\r\n* if a foreign-key exists between the joined tables, look-up the attribute on the joined instance\r\n* otherwise specify a join attribute by specifying an alias on the join predicate" ]

[]

[]

[ "looks like the model.insert call is not making the primary key. i have not intentionally passed in a primary key, also possible the record coming in has null on the primary key already and you are not overwriting that? I am going to try .create instead of .insert", "Peewee has a convention of using `id` for an auto-incrementing primary key field. Perhaps you're subclassing models which override the primary key?\r\n\r\nCan you provide example code I can use to reliably replicate this issue? Without that I'm a little at a loss how to replicate this or even verify there is a bug.", "Please comment with additional details or steps I can follow to replicate, and I will be happy to reopen and investigate.", "Hello,\n\nThanks for the help.\n\nI have resolved this on my end.\n\nIssue comes up if one has a postgres 9.6 version. I moved to 10 postgres and it went away.\nHowever, I also was more brutal in my code as related to ID generation and storage, and perhaps that also fixed the problem.\n\nEitherway I am in peewee 3x and looks to be working now.\n\nThanks!!!!\nEvan\n\nSent with [ProtonMail](https://protonmail.com) Secure Email.\n\n‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐\nOn May 8, 2018 9:45 AM, Charles Leifer <[email protected]> wrote:\n\n> Please comment with additional details or steps I can follow to replicate, and I will be happy to reopen and investigate.\n>\n> —\n> You are receiving this because you authored the thread.\n> Reply to this email directly, [view it on GitHub](https://github.com/coleifer/peewee/issues/1598#issuecomment-387407156), or [mute the thread](https://github.com/notifications/unsubscribe-auth/AXFzJlcgsNjM032U-b8jr-Y-ANUeknJIks5twaFjgaJpZM4T0FOF)." ]

[]

[]

[ "solved." ]

[]

[]

[ "Those \".\"-commands are only implemented in the sqlite shell. They're not part of the sql interface.", "Check out the code in SqliteDatabase like get_tables, get_columns, etc if\nyou want to introspect the database. There's also the reflection module in\nplayhouse.reflection. Check the docs.\n\nOn Thu, May 3, 2018, 2:48 AM 夏天的风铃_ <[email protected]> wrote:\n\n> I got a syntax error when using db.execute_sql to get sqlite3 table schema,\n>\n> Reproduce:\n>\n> In [135]: db = SqliteDatabase('test.db')\n> ...:\n> ...:\n> ...: class ExampleTable(Model):\n> ...: class Meta:\n> ...: table_name = 'test_table'\n> ...: database = db\n> ...:\n> ...: created_time = DateTimeField(default=datetime.datetime.now)\n> ...: update_time = DateTimeField(default=datetime.datetime.now)\n> ...:\n>\n> In [136]: ExampleTable\n> Out[136]: __main__.ExampleTable\n>\n> In [137]: ExampleTable.create_table()\n>\n> In [138]: db.execute_sql('.schema')\n> ---------------------------------------------------------------------------\n> OperationalError Traceback (most recent call last)\n> ~/.local/share/virtualenvs/pycsvsql-TYJ8UyNv/lib/python3.6/site-packages/peewee.py in execute_sql(self, sql, params, commit)\n> 2566 try:\n> -> 2567 cursor.execute(sql, params or ())\n> 2568 except Exception:\n>\n> OperationalError: near \".\": syntax error\n>\n> During handling of the above exception, another exception occurred:\n>\n> OperationalError Traceback (most recent call last)\n> <ipython-input-138-e0357ff2f49e> in <module>()\n> ----> 1 db.execute_sql('.schema')\n>\n> ~/.local/share/virtualenvs/pycsvsql-TYJ8UyNv/lib/python3.6/site-packages/peewee.py in execute_sql(self, sql, params, commit)\n> 2572 else:\n> 2573 if commit and not self.in_transaction():\n> -> 2574 self.commit()\n> 2575 return cursor\n> 2576\n>\n> ~/.local/share/virtualenvs/pycsvsql-TYJ8UyNv/lib/python3.6/site-packages/peewee.py in __exit__(self, exc_type, exc_value, traceback)\n> 2365 new_type = self.exceptions[exc_type.__name__]\n> 2366 exc_args = exc_value.args\n> -> 2367 reraise(new_type, new_type(*exc_args), traceback)\n> 2368\n> 2369 EXCEPTIONS = {\n>\n> ~/.local/share/virtualenvs/pycsvsql-TYJ8UyNv/lib/python3.6/site-packages/peewee.py in reraise(tp, value, tb)\n> 173 def reraise(tp, value, tb=None):\n> 174 if value.__traceback__ is not tb:\n> --> 175 raise value.with_traceback(tb)\n> 176 raise value\n> 177\n>\n> ~/.local/share/virtualenvs/pycsvsql-TYJ8UyNv/lib/python3.6/site-packages/peewee.py in execute_sql(self, sql, params, commit)\n> 2565 cursor = self.cursor(commit)\n> 2566 try:\n> -> 2567 cursor.execute(sql, params or ())\n> 2568 except Exception:\n> 2569 if self.autorollback and not self.in_transaction():\n>\n> OperationalError: near \".\": syntax error\n>\n> I was expecting something like,\n>\n> sqlite> .schema\n> CREATE TABLE IF NOT EXISTS \"test_table\" (\"id\" INTEGER NOT NULL PRIMARY KEY, \"created_time\" DATETIME NOT NULL, \"update_time\" DATETIME NOT NULL);\n>\n> Can you tell me how to fix it?\n>\n> —\n> You are receiving this because you are subscribed to this thread.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/coleifer/peewee/issues/1596>, or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AAHUprxEhAxcns6tLtO0MPv2tREa9WdWks5turZmgaJpZM4TwodY>\n> .\n>\n" ]

[]

[]

[ "Thank you, this is helpful." ]

[]

[]

[ "peewee version: 3.2.2\r\ndatabase: mysql 5.6", "i changed the sql to\r\n```sql\r\nCREATE TABLE IF NOT EXISTS `trial_books` (`id` INTEGER AUTO_INCREMENT NOT NULL PRIMARY KEY, `created_at` DATETIME NOT NULL, `updated_at` DATETIME NOT NULL, `book_id` INTEGER UNSIGNED NOT NULL, FOREIGN KEY (`\r\n book_id`) REFERENCES `books` (`id`))\r\n``\r\n\r\nit works.\r\n\r\nthat is, ``book_id` INTEGER NOT NULL UNSIGNED` is a wrong sql for mysql\r\n\r\n\r\n", "[13.1.17 CREATE TABLE Syntax](https://dev.mysql.com/doc/refman/5.6/en/create-table.html)\r\n\r\n```\r\ncolumn_definition:\r\n data_type [NOT NULL | NULL] [DEFAULT default_value]\r\n [AUTO_INCREMENT] [UNIQUE [KEY]] [[PRIMARY] KEY]\r\n [COMMENT 'string']\r\n [COLUMN_FORMAT {FIXED|DYNAMIC|DEFAULT}]\r\n [STORAGE {DISK|MEMORY|DEFAULT}]\r\n [reference_definition]\r\n\r\ndata_type:\r\n BIT[(length)]\r\n | TINYINT[(length)] [UNSIGNED] [ZEROFILL]\r\n | SMALLINT[(length)] [UNSIGNED] [ZEROFILL]\r\n | MEDIUMINT[(length)] [UNSIGNED] [ZEROFILL]\r\n | INT[(length)] [UNSIGNED] [ZEROFILL]\r\n | INTEGER[(length)] [UNSIGNED] [ZEROFILL]\r\n | BIGINT[(length)] [UNSIGNED] [ZEROFILL]\r\n | REAL[(length,decimals)] [UNSIGNED] [ZEROFILL]\r\n | DOUBLE[(length,decimals)] [UNSIGNED] [ZEROFILL]\r\n | FLOAT[(length,decimals)] [UNSIGNED] [ZEROFILL]\r\n | DECIMAL[(length[,decimals])] [UNSIGNED] [ZEROFILL]\r\n | NUMERIC[(length[,decimals])] [UNSIGNED] [ZEROFILL]\r\n | DATE\r\n | TIME[(fsp)]\r\n | TIMESTAMP[(fsp)]\r\n | DATETIME[(fsp)]\r\n | YEAR\r\n | CHAR[(length)]\r\n [CHARACTER SET charset_name] [COLLATE collation_name]\r\n | VARCHAR(length)\r\n [CHARACTER SET charset_name] [COLLATE collation_name]\r\n | BINARY[(length)]\r\n | VARBINARY(length)\r\n | TINYBLOB\r\n | BLOB[(length)]\r\n | MEDIUMBLOB\r\n | LONGBLOB\r\n | TINYTEXT\r\n [CHARACTER SET charset_name] [COLLATE collation_name]\r\n | TEXT[(length)]\r\n [CHARACTER SET charset_name] [COLLATE collation_name]\r\n | MEDIUMTEXT\r\n [CHARACTER SET charset_name] [COLLATE collation_name]\r\n | LONGTEXT\r\n [CHARACTER SET charset_name] [COLLATE collation_name]\r\n | ENUM(value1,value2,value3,...)\r\n [CHARACTER SET charset_name] [COLLATE collation_name]\r\n | SET(value1,value2,value3,...)\r\n [CHARACTER SET charset_name] [COLLATE collation_name]\r\n | spatial_type\r\n```", "You're probably best off creating your own field type.\r\n\r\n```python\r\nclass UnsignedIntegerField(IntegerField):\r\n field_type = 'INTEGER UNSIGNED'\r\n```" ]

[]

[]

[ "Fields have `null=False` by default, or in other words, by default fields do not allow null values.", "@coleifer thanks for take the time to answer Peewee beginners questions. You are doing a very good job here 👏\r\n\r\none more ... \r\n\r\nI create a SQLite db and a model with a DateField, say:\r\n```\r\nclass MyModel(BaseModel):\r\n n1 = IntegerField(unique=True)\r\n date1 = DateField(unique=True)\r\n```\r\nThen the model is populate from a json file:\r\n```\r\n with open('json.jl') as f:\r\n for line in f.readlines()\r\n data = MyModel(**json.loads(line))\r\n data.save()\r\n```\r\nThe above code is running fine, UNIQUE constraints raise exceptions has expected. \r\nBut I put, intentionally, wrong values on `date1` field like '2017-1-59' or 'any string' and the values get store without `Exception`. I thought that `DateField` enforce some constraint or validation. \r\n\r\nWhat I miss here??\r\n ", "You should be passing them in as Python `datetime.date` objects rather than as strings.", "`DateField` only set the field type on table creation, but don´t do validation beyond null check or unique constraints? \r\n", "It's more complicated than that, unfortunately.\r\n\r\nSQLite doesn't have a true date/time data-type. Databases like MySQL or Postgres would raise an error if you tried to insert garbage data, but with SQLite you need to either represent the date-time as a string (in which case you should use YYYY-mm-dd HH:MM:SS to ensure lexicographic sorting) or an integer timestamp.\r\n\r\nIf you want to enforce validation, you can subclass DateTimeField (or DateField or whatever) and modify the `db_value()` method to ensure strings are valid dates (or datetimes or whatever).", "@coleifer now is clear to me. Thanks a lot for the details in the explanation.\r\n\r\nI take your advice and convert date str to `datetime.date` before save it.\r\n\r\n" ]

[]

[]

[ "Thanks for reporting, should be fixed.", "I added the following methods to select queries:\r\n\r\n* `union_all()`\r\n* `union()`\r\n* `intersect()`\r\n* `except_()`" ]

[]

[]

[ "Given how easy it is to add this to your own base model class, I'm going to pass on adding similar functionality to peewee. As you noted, the proper way to guarantee uniqueness is to have a unique constraint.\r\n\r\n```python\r\n@classmethod\r\ndef get_unique_row(cls, *expr):\r\n query = cls.select().where(*expr).limit(2)\r\n results = list(query)\r\n if len(results) == 1:\r\n return results[0]\r\n elif len(results) == 0:\r\n raise cls.DoesNotExist\r\n else:\r\n raise NonUniqueException\r\n```", "That's what I need! Thanks!" ]

[]

[]

[ "Thank you, I've submitted an equivalent cleaned-up patch with a test-case: d92036e7602f29c5ce4dae4ff2ffd09c28fab218", "Thanks very much, I'll be sure to include a test case if I submit another PR in the future." ]

[]

[]

[ "Thanks, I've updated the method signature for `PostgresqlExtDatabase` and mentioned in the docs that the parameter is internal-use-only. fbb4ded7000d5163344c67236fee7a1fae38991c" ]

[]

[]

[ "Thank you!" ]

[]

[]

[ "Columns are exposed as attributes on model classes. As such, they must be valid Python identifiers. Peewee makes allowances for the weird types of column-names you might see by allowing you to specify the `column_name` parameter when defining your field, as you have done in your example model definition.\r\n\r\nAs long as you're working with the data in Python *as Python objects* it makes sense to me that you'd need to use Pythonic identifiers. As you said, you're importing this from a CSV file ... it's unclear to me why, if you're defining the schema, you wouldn't take that opportunity to make it conventional?\r\n\r\nTake a look here for a thorough explanation and rationale: https://launchbylunch.com/posts/2014/Feb/16/sql-naming-conventions/\r\n\r\nPeewee supports the above naming conventions, which are considered to be the \"80%\" use-case, while making it possible to still work with unconventional schemas (\"the 20% case\"). I think that's how it shall remain.", "As an additional note, using the getitem APIs is particularly user-hostile because:\r\n\r\n* No tab-completion when debugging\r\n* No validation when code is being interpreted (hence, no AttributeError)\r\n* Additional typing (4 characters for brackets+quotes vs 1 for dot).\r\n* Non-obvious -- fields are model-class attributes, you should access them as you would any class attribute.", "> As long as you're working with the data in Python as Python objects it makes sense to me that you'd need to use Pythonic identifiers. As you said, you're importing this from a CSV file ... it's unclear to me why, if you're defining the schema, you wouldn't take that opportunity to make it conventional?\r\n\r\nUnfortunately the naming is not up to me. How would you propose naming a column like `2MASS` (Two Micron All-Sky Survey) to a Python identifier that preserves its historical name possibly `TMASS` but by the link you provided it follow pythonic variable names very closely so maybe `tmass`.\r\n\r\nYou propose for every schema I wish to create via importing some csv, I change the column names on the csv (given I'm importing via list of dicts) so it matches python convention. Then, I have to create a Model with this new columns names while also specifying the old \"unconventional\" columns names to the Field argument `column_name`. The 2nd step is reasonable but the 1st step shouldn't be needed as my Model knows if I refer to \"2MASS\" it should recognize it's the same w/e I named the Python conventional attribute by looking at the Field attribute `column_name`. \r\n\r\nSorry if it's a bit confusing it was difficult to word this out.", "Theoretically once you've got your data into your db you don't need to think about what it was originally named in the csv...so we're talking about a one-time data-loading operation...\r\n\r\nI'd suggest making a translation table... untested code but should convey the idea hopefully:\r\n\r\n```python\r\nclass MyModel(Model):\r\n tmass = FloatField(column_name='2mass')\r\n # etc...\r\n\r\nttable = {f.column_name: f.name for f in MyModel._meta.sorted_fields}\r\ndef translate(in_data):\r\n return {ttable[k]: v for k, v in in_data.items()}\r\n\r\nfor row_dict in csv_file:\r\n MyModel.insert(translate(row)).execute()\r\n```" ]

[]

[]

[ "Ew interesting I wonder if that's been reported to python, since it's in the urllib.parse module.", "https://bugs.python.org/issue18140" ]

[]

[]

[ "So, SQLAlchemy uses an identity-map to do this kind of thing. Which brings a lot of other logic into the equation, such as the concept of session/object lifetimes, aggregating changes during commit, etc.\r\n\r\nPeewee, on the other hand, is an active-record ORM. Objects are containers for row data rather than canonical representations of the rows themselves. I find this mental model easier to work with. I know which queries are going to be executed and when they'll run.\r\n\r\nIt's a matter of preference, but peewee is fundamentally different from SQLAlchemy in this regard." ]

[]

[]

[ "> Are the window function queries supported for MySQL databases?\r\n\r\nI'm not sure, although they are supported with integration tests for Postgresql.", "You might try this for now:\r\n\r\n```python\r\nw = Window(partition_by=[PROJECT.date])\r\nquery = (aap\r\n .select(aap.date, aap.animal, aap.value, fn.AVG(aap.value).over(w).alias('avg'))\r\n .where((aap.date == '2018-02-08') & (aap.animal == 'DOG'))\r\n .window(w)) # Try adding this.\r\n```", "I tried that too from your example in the docs but I just realized my MariaDB is running on MySQL 5.6 and window functions don't seem to come out until MySQL 8.0 so it was doomed from the start. Thank you for your help though", "Yeah, recent MySQL and MariaDB have support but I haven't tested it personally." ]

[]

[]

[ "You mean the 3.7 data-classes? Sure...just provide your own constructor function and call .objects(), e.g.:\r\n\r\n```python\r\ndef make_data_class(data_dict):\r\n # do whatever.\r\n return DataClass(**data_dict)\r\n\r\nfor data_class_obj in some_query.objects(make_data_class):\r\n ...\r\n```", "Thank you. I am sorry but I am a newbie. After adapting your code I am getting the following error:\r\n\r\n```AttributeError: 'SelectQuery' object has no attribute 'objects'```", "What version of peewee are you using?", "peewee 2.10.1\r\n", "Peewee 3.2.5 is the most recent version.", "Thank you." ]

[]

[]

[ "Sure, with the caveat that the new value will not be available to your code unless you explicitly re-fetch the new value.\r\n\r\n```python\r\nclass TimestampTest(Model):\r\n name = CharField(max_length=20)\r\n create_time = DateTimeField(constraints=[SQL('DEFAULT CURRENT_TIMESTAMP')])\r\n last_modify_time = DateTimeField(constraints=[SQL('DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP')])\r\n```", "Thanks, but I find it can only be useful when using Model.update(). If I use Model.save(), it doesn't auto update.\r\n\r\n```\r\n query = TimestampTest.update(name=\"37a_000\").where(TimestampTest.id == 1)\r\n query.execute()\r\n```\r\nThis will update the last_modify_time.\r\n\r\n```\r\n test = TimestampTest.get(id=1)\r\n test.name = \"37a_0a\"\r\n test.save()\r\n```\r\nThis doesn't update.", "Good point. You'll need to specify that peewee should only save the name field:\r\n\r\n```python\r\ntest.save(only=(TimestampTest.name,))\r\n```\r\n\r\nThat ought to do the trick." ]

[]

[]

[ "That format is no good because it doesn't sort lexicographically. Sqlite doesn't have a dedicate date/time data-type. You'll want to convert those to YYYY-mm-ddTHH:MM:SS so they sort correctly.\r\n\r\nPeewee *can* read values like that if you specify the strptime format, however comparisons like the one in your example will not work correctly:\r\n\r\n```python\r\nlousy_datetime = DateTimeField(formats=['%m/%d/%Y %I:%M %p'])\r\n```\r\n\r\nIt should be possible to also craft a one-time migration using sqlite's date/time functions: https://www.sqlite.org/lang_datefunc.html" ]

[]

[]

[ "Sounds like `pipenv` has an old version of peewee on your computer.\r\n\r\nIn peewee 3.x `ManyToManyField` has moved into `peewee`, so:\r\n\r\n```python\r\n# 3.x\r\nfrom peewee import ManyToManyField\r\n```\r\n\r\nI'm not familiar with `pipenv` but it sounds like it's using an older version of peewee on your computer and the newer 3.x on your server.", "Thank you. This seemed to be the case for me." ]

[]

[]

[ "I wouldn't say you're doing anything wrong. What's happening is the result-rows from the cursor look like:\r\n\r\n```sql\r\nselect t1.id, t1.user_id, t1.content, t2.id, t2.username \r\nfrom tweet as t1 \r\ninner join users as t2 on (t1.user_id=t2.id) \r\nwhere t2.id = 1 \r\nunion \r\nselect t3.id, t3.user_id, t3.content, t4.id, t4.username \r\nfrom tweet as t3 \r\ninner join users as t4 on (t3.user_id=t4.id);\r\n```\r\n\r\nProduces:\r\n\r\n```\r\nid|user_id|content|id|username\r\n 1| 1| u1-1| 1| u1\r\n 2| 1| u1-2| 1| u1\r\n 3| 2| u2-1| 2| u2\r\n```\r\n\r\nWhen peewee iterates over the result rows, it sees columns named (id, user_id, content, id, username). The 2nd id corresponds to the user's id rather than the tweet id. You can fix this in a number of ways without needing to update peewee:\r\n\r\n1. Don't select the user's id.\r\n2. Alias the user's id to a different attribute.\r\n\r\nWith the patch I've just pushed (80a2048837100c102d5387366cb1a5531739cb91) it should no longer be a problem, because:\r\n\r\n1. Instead of putting all attributes onto the selected model when a UNION is present, attempt to resolve the model graph. So the user's \"id\" and \"username\" would be put on Tweet.user (e.g. tweet.user.id, tweet.user.username).\r\n2. When returning a flat result, do not overwrite attrs. So \"id\" in your example would be the tweet id since that's the first \"id\" column we see. The 2nd user \"id\" would not be stored.", "Got it. Looks like 3.2.4 works for me. Thanks!" ]

[]

[]

[ "This is simply how peewee is organized. Peewee is a standalone python module and all extras/extensions are included in a separate namespace.", "I see your point. My suggestion was to move naming in the direction of making `playhouse` module name more related to peewee. A middle ground may be `peweeplayhouse`?", "It's been this way since ... 2010? I'm not too interested in changing it." ]

[]

[]

[ "Right, so you named a column the same as a classmethod.\r\n\r\nThe workaround here is to:\r\n\r\n```python\r\nclass Foo(Model):\r\n update = TimestampField() # uh-oh.\r\n\r\n# do this instead:\r\nclass Foo(Model):\r\n update_ = TimestampField(column_name='update') # added \"_\" to avoid name conflict.\r\n```\r\n\r\nI suppose I can add this to the docs as well.", "A document update would be extremely helpful. Not sure how one can find it there, but atleast one may get lucky.", "For sure, there's starting to be a bit of sprawl in the docs. If you had suggestions for re-organizing I'd be open to any ideas.\r\n\r\nAdded a note in the bottom of the \"Fields\" sub-section (after creating custom field).", "I was getting that feeling too. One has to balance verbosity with tersity and finding that spot is hard. I'm bad at documentation, but there's nothing like more documentation (just more maintenance :-). \r\nWish I had some out-of-the-box ideas..." ]

[]

[]

[ "Some quick testing revealed a bug in the cloning of the from-list and the join dictionaries. Pushed a fix.", "For what it's worthy, queries should be immutable -- so no need to call clone():\r\n\r\n```python\r\nquery = Tweet.select()\r\nnew_query = query.join(User)\r\n# query -> select * from tweet\r\n# new_query -> select * from tweet join user\r\n```" ]

[]

[]

[ "You're _much_ better off just doing this:\r\n\r\n```python\r\n\r\nclass User(ModelBase):\r\n name = CharField()\r\n class Meta:\r\n table_name = 'users'\r\n\r\nclass Relationship(ModelBase):\r\n from_user = ForeignKeyField(User, backref='following')\r\n to_user = ForeignKeyField(User, backref='followers')\r\n```" ]

[]

[]

[ "You might try using `Param` or `Passthrough` around your list, e.g.\r\n\r\n```python\r\n.where(MyModel.field == Passthrough(['element', 'another']))\r\n```", "In peewee 3.x, for what it's worth, it's not necessary to use a wrapper around the value, you can express the equality as you'd expect:\r\n\r\n```python\r\nquery = SomeModel.get(SomeModel.array_field == ['foo', 'bar', 'baz'])\r\n```", "> ```python\r\n> .where(MyModel.field == Passthrough(['element', 'another']))\r\n> ```\r\n\r\nThis indeed does the trick, interesting. I was using `Clause` as a workaround, but `Passthrough`/`Param` (both work) makes it a bit cleaner and safer.\r\n\r\nWill definitively upgrade to 3 soon. Thanks.", "Actually, maybe I could ask in which (other) cases do we need `Param`/`Passthrough`? Docs don't mention them.\r\n\r\nOr are these completely removed in 3.x? **Edit:** seems so as they're not found in ``peewee.py`` anymore.", "Removed in 3.x. For 2.x you'll want to use it in places where you're passing a non-scalar type (like a list or something) to a database driver that understands those types...i.e., psycopg2 understands lists and dicts." ]

[]

[]

[ "When calling `switch()` you need to pass the model you are switching the context to. The error message is not very helpful, but you should change your code in this manner:\r\n\r\n```python\r\n.join(User).switch(PlatformBridge).join(Bot)\r\n```", "I've also amended the implementation of `switch()` so that when called with no parameters it will default to switching to the query's model.", "Ok, thank you for the quick response!" ]

[]

[]

[ "Thanks for reporting, I'll take a look.", "Fixed, thanks.", "Works great, thanks for the quick response! 🙂" ]

[]

[]

[ "Fix problem_1\r\n```\r\n\t@hybrid_method\r\n\tdef is_valid(self):\r\n\t\treturn (self.not_after > datetime.now()) & (self.not_before < datetime.now())\r\n```\r\n`Cert.select().where(Cert.is_valid() == True)`", "Here is perhaps a cleaner way of implementing `is_valid()`:\r\n\r\n```python\r\n\r\n @hybrid_property\r\n def is_valid(cls):\r\n n = datetime.datetime.now()\r\n return self.not_before <= n <= self.not_after\r\n\r\n @is_valid.expression\r\n def is_valid(self):\r\n now = SQL('current_timestamp')\r\n return (self.not_before <= now) & (self.not_after >= now)\r\n```\r\n\r\nAs far as \"valid_for\", you can pass a `datetime.timedelta` to Peewee and it should do the right thing:\r\n\r\n```python\r\n\r\n @hybrid_property\r\n def valid_for(self):\r\n return (self.not_after - datetime.datetime.now()).days\r\n\r\n @valid_for.expression\r\n def valid_for(self):\r\n return fn.AGE(self.end)\r\n\r\nquery = Cert.select().where(Cert.valid_for > datetime.timedelta(days=99))\r\n```\r\n\r\nDoes that address your problem? Also note you do not need to write \"== True\" in your expressions.", "@coleifer Thank you :)" ]

[]

[]

[ "Ahh, you're right, sorry I missed that. I can add it." ]

[]

[]

[ "Peewee will work with `pymysql` or `mysql-python`. It sounds like you have an issue with your module-import path. This is not an issue with Peewee -- I'd suggest trying StackOverflow.", "`mysqlclient` is recommend", "So for mysql:\r\n\r\n* [pymysql](https://github.com/PyMySQL/PyMySQL) is a pure-python mysql client, works with python 2 and 3. Peewee will use attempt to use pymysql first.\r\n* [mysqlclient](https://github.com/PyMySQL/mysqlclient-python) uses a c extension and supports python 3. It exposes a `MySQLdb` module. Peewee will attempt to use this module if pymysql is not installed.\r\n* `mysql-python` is also called [MySQLdb1](https://github.com/farcepest/MySQLdb1) and is legacy and should not be used. Since this shares the same module name as mysqlclient, same applies.\r\n* [mysql-connector python](https://github.com/mysql/mysql-connector-python) pure-python (I think??) supports python 3. To use this driver you can use `playhouse.mysql_ext.MySQLConnectorDatabase`.", "@weaming mysqlclient did not seem to work in my case.\r\n@coleifer -- `pymysql` worked without issue on first attempt.\r\nThanks!", "> @weaming mysqlclient did not seem to work in my case.\r\n> @coleifer -- `pymysql` worked without issue on first attempt.\r\n> Thanks!\r\n\r\n`mysqlclient` further depends on some other dependencies, as stated in the [official doc](https://github.com/PyMySQL/mysqlclient-python), . It depends on which OS you are using, slight difference between macOS and Ubuntu, for instance." ]

[]

[]

[ "Interesting... so what you're running into is -- you'd like to add a new, non-nullable, unique field with a dynamic default. The migrator's `apply_default()` helper is implemented such that, if the field's default is callable, it is only called once:\r\n\r\n```python\r\n def apply_default(self, table, column_name, field):\r\n default = field.default\r\n if callable(default):\r\n default = default()\r\n\r\n return (self.make_context()\r\n .literal('UPDATE ')\r\n .sql(Entity(table))\r\n .literal(' SET ')\r\n .sql(Expression(\r\n Entity(column_name),\r\n OP.EQ,\r\n field.db_value(default),\r\n flat=True)))\r\n```\r\n\r\nI'm leery of changing this to run a separate UPDATE for every row that may already exist in the table.\r\n\r\nI'd propose instead that you do something like this:\r\n\r\n1. use migrator to add the field (non-unique and nullable)\r\n2. in a transaction/loop update the existing rows\r\n3. use migrator to make field not-null and add a unique index on it.\r\n\r\nWDYT?", "Your suggestion is in fact what I did. LMK if you ever want to address it in peewee official.\r\n\r\n```python\r\nmigrator = MySQLMigrator(db)\r\n\r\nclass StrUUIDField(peewee.CharField):\r\n def db_value(self, value):\r\n if isinstance(value, uuid.UUID):\r\n return value.hex\r\n try:\r\n return uuid.UUID(value).hex\r\n except (TypeError, ValueError):\r\n return value\r\n\r\n def python_value(self, value):\r\n if isinstance(value, uuid.UUID):\r\n return value.hex\r\n return None if value is None else uuid.UUID(value).hex\r\n \r\ndef add_unique_column(model, field_name='uuid', field_default=uuid.uuid4):\r\n \"\"\"Add uuid field to a given model type.\r\n This is here because calling add_column calls apply_default, resulting in every row\r\n getting the same initial value. Not good when you want a unique value.\r\n \"\"\"\r\n\r\n # First add the column with null as the default value. No indexes.\r\n field_definition = StrUUIDField(null=True, index=False, unique=False)\r\n migrate(\r\n migrator.add_column(model._meta.table_name, field_name, field_definition),\r\n )\r\n\r\n # Update every row with a unique uuid\r\n for inst in model.select(model.id):\r\n setattr(inst, field_name, field_default() if callable(field_default) else field_default)\r\n inst.save()\r\n\r\n # Now set the column to NOT NULL and create the unique index\r\n migrate(\r\n migrator.add_not_null(model._meta.table_name, field_name),\r\n migrator.add_index(model._meta.table_name, (field_name,), unique=True)\r\n )\r\n```", "I think I'll pass but will keep this in mind should it come up again. Thanks for sharing your implementation.", "For what it's worth, I too ran into this and was confused by the behavior.\r\n\r\nIf the migrator's `apply_default()` determines that the default is callable (i.e., dynamic), isn't caching the value breaking the expectation of the user?\r\n\r\nI understand the reason for passing on this implementation, but it would be helpful to throw a warning or error explaining this limitation (or even pointing them to this issue!)\r\n" ]

[]

[]

[ "And the usage of \r\n \r\n with db:\r\n do_some_query()\r\n\r\nstill raise the MySQL gone away error", "f0a6f11aea19089af34befed2dab886706e1593a", "\r\nWhy the super class of PooledDatabase is object? there is no connect function. dose the super class is Database? ", "`PooledDatabase` is used in multi-class inheritance later on in the module." ]

[]

[]

[ "As far as I know sqlite doesn't support adding constraints. Can you try executing the equivalent alter table query and see what happens?", "Sure thing. It looks like `ALTER TABLE` works with the `ON DELETE` clause:\r\n\r\n```\r\n~/dev$ sqlite3 testdb\r\nSQLite version 3.19.3 2017-06-27 16:48:08\r\nEnter \".help\" for usage hints.\r\nsqlite> PRAGMA foreign_keys = ON;\r\nsqlite>\r\nsqlite> CREATE TABLE IF NOT EXISTS \"table\" (\r\n ...> id INTEGER PRIMARY KEY AUTOINCREMENT\r\n ...> );\r\nsqlite>\r\nsqlite> ALTER TABLE \"table\" ADD COLUMN \"fk\" INTEGER REFERENCES \"table\"(id) ON DELETE SET NULL;\r\nsqlite>\r\nsqlite> .schema table\r\nCREATE TABLE IF NOT EXISTS \"table\" (\r\n id INTEGER PRIMARY KEY AUTOINCREMENT\r\n, \"fk\" INTEGER REFERENCES \"table\"(id) ON DELETE SET NULL);\r\nsqlite>\r\n```\r\n\r\n", "I believe this should be fixed in 449450d738a8c8f2893e5309d03d03bc249e9d7e", "Added test-case which shows the \"ON DELETE\" bits are being carried-over into the migration. Thanks for reporting.", "Thanks @coleifer. I've tested on master and it's working correctly now 👍" ]

[]

[]

[ "Well... you can wrap your operations in a transaction, using `atomic()`. `atomic()` is a context-manager or decorator, but if you want to use it in the above middleware-type API, you should be able to:\r\n\r\n```python\r\n\r\nclass TransactionPerRequest(object):\r\n def process_request(self, req, resp):\r\n req._txn = self.db.atomic()\r\n req._txn.__enter__()\r\n\r\n def process_response(self, req, resp, resource):\r\n if not self.db.is_closed():\r\n req._txn.__exit__(None, None, None)\r\n self.db.close()\r\n\r\n def __init__(self, db):\r\n self.db = db\r\n```", "Will this also prevent (non-null, etc) constraints from being validated on creation time? A way to enable a delay to actual saving time would be great.", "> Will this also prevent (non-null, etc) constraints from being validated on creation time?\r\n\r\nIt should, as the INSERTs are executed -- they are simply executed in a transaction which is not committed until the `atomic` block exits (which is in the process_response example).\r\n\r\nIf you're trying to postpone actually inserting the records (and dealing with any integrity-errors, etc) -- I'd suggest using a Queue and pushing the models into it, then at the end of the request consume the queue and save all the models." ]

[]

[]

[ "```python\r\ns1 = SomeModel.select().where(...)\r\ns2 = SomeModel.select().where(...)\r\nquery = (s1 & s2).order_by(fn.RANDOM())\r\n```", "@coleifer \r\nWhenever I'm trying to iterate through this new query or make a list I get error:\r\n```\r\npeewee.OperationalError: 1st ORDER BY term does not match any column in the result set\r\n```\r\nDoes `ModelCompoundSelectQuery` support iterations?", "What database are you using?\r\n\r\nAnd yes, it supports iteration. The error is in the SQL query.", "I use mostly `SqliteQueueDatabase` from `playhouse.sqliteq`.\r\nBut I also tried this with standard `SqliteDatabase` and got the same error.\r\nPeewee version: `3.2.2`, Python `3.6.3`", "This works:\r\n\r\n```python\r\nclass Register(BaseModel):\r\n value = IntegerField()\r\n\r\nclass Data(BaseModel):\r\n key = TextField()\r\n\r\ndb.create_tables([Register, Data])\r\n\r\nfor i in range(10):\r\n Register.create(value=i)\r\n\r\nfor k in range(10):\r\n Data.create(key='k%s' % k)\r\n\r\ndata = Data.select(fn.RANDOM(), Data)\r\nreg = Register.select(fn.RANDOM(), Register)\r\nunion = (data | reg).order_by(SQL('1'))\r\nfor row in union.tuples():\r\n print(row)\r\n```\r\n\r\nBasically it selects a random value and uses it as the first column in each query. Then in the union query, we order all results by the first column (a random value)." ]

[]

[]

[ "The error message is out-of-date. The parameter name is \"field\" (no \"rel_\"). It refers to the field on the model your FK points to - typically the primary key.", "```\r\n# e.g., to reference the \"id\" field of ServiceCategory:\r\nForeignKeyField(db.ServiceCategory, db.ServiceCategory.id, null=True, on_delete='SET NULL')\r\n```" ]

[]

[]

[ "Thanks I'll pass on this for now. It'd be nice if the python domain of ReST supported this type of annotation but I couldn't find it." ]

[]

[]

[ "Going to pass, thanks." ]

[]

[]

[ "Try:\r\n\r\n```python\r\nfn.snippet(FTSPage._meta.entity).alias('extract')\r\n```", "FTS5 is a completely different library, really. I'd suggest doing a very close reading of the fts5 sqlite documentation if you haven't already. Personally, I've gone back to FTS4 because FTS5 was just a bit problematic (especially dealing with special chars in search queries).", "Thanks, `._meta.entity`did the trick (in the sense that now I have a logical error someplace else and an empty query result, but at least it runs). I was using 2.8.x, so I missed any doc updates in the meantime.\r\n\r\nAs to FTS5, I'll probably wait, then. I did check out the docs briefly, but since I need accented character support I'll to a test fork...\r\n\r\nThanks for the quick reply!", "Well, feel free to share the model definitions and the query, be happy to try and troubleshoot.", "Thanks, will check a few things first, since I need to validate what’s going in to the FTS table - will reply here if it’s not a content error...", "This is the only page I can find discussing peewee and ```fts5``` ```snippet()``` on the web. Hope the following helps someone in the future, possibly me.\r\n\r\nI was able to get the snippet out of an ```FTS5Model``` class using the following:\r\n```fn.snippet(Record._meta.entity, 1, '<b>', '</b>', '...', 10).alias('snippet')```\r\n\r\nI am, however, doing as @coleifer and dropping ```FTS5Model``` for ```FTSModel``` with ```fts4.``` My reason is that I could not find a way to store unique records using ```FTS5Model``` but I know how to do it with ```FTSModel``` + ```Model```. It seems ```fts5```is not mature enough yet." ]

[]

[]

[ "I think type hints are misguided and unpythonic, and it's my stance that they will never be supported by peewee. Python is a high-level dynamic language, peewee plays to these strengths. You couldn't implement peewee in go, it'd look completely different.\r\n\r\nI enjoy statically typed languages. When I want static typing I use c or go. When I want dynamic or metaprogramming I use python.\r\n\r\nThese are my opinions and I understand that others have their own views. My goals for peewee are to make it composable and consistent, and I feel I can do that best by using python's dynamism.", "I understand your clause fully, just note that type hints could be supported where dynamic python magic is not needed. Plus in this case the library itself wouldn't imbue type hints - it would just support users declaring them. That would require changes (ie. something like what I suggested above) and I understand that you're reluctant to add that. Anyway, if you (or anyone here) comes up with a simpler idea, chime in.\r\n\r\nMaybe I'll ask about this on mypy tracker as well. I'll ping back here if there's any further insight.", "@tuukkamustonen oh I've just got your proposition. I'ts cludgy. I come to something like User.c.name (stealed from sqlalchemy). My temporary solution is to turn off typing in queries or cast User.name to any (sadly python have no typescript-style casts like (obj as any) for that purpose, but we have `cast()` function, heh)", "@tuukkamustonen, @enomado can you share a snippet of code of how you \"by pass\" mypy errors.\r\nI'm stuck on this\r\n```\r\nmodel/__init__.py:5: error: Cannot find module named 'peewee'\r\nmodel/__init__.py:17: error: Name 'SqliteDatabase' is not defined\r\nmodel/__init__.py:20: error: Name 'Model' is not defined\r\nmodel/__init__.py:26: error: Name 'IntegerField' is not defined\r\nmodel/__init__.py:27: error: Name 'IntegerField' is not defined\r\n```\r\n", "Well I could silence `mypy` creating a very simple local `peewee.pyi` , for my needs:\r\nstubs/peewee.pyi\r\n```\r\nimport typing\r\n\r\nclass Field:\r\n def __init__(self, **kwargs) -> None: ...\r\n\r\nclass CharField(Field): ...\r\n\r\nclass IntegerField(Field): ...\r\n\r\nclass DateField(Field): ...\r\n\r\nclass Model:\r\n def __init__(self, **kwargs) -> None: ...\r\n\r\nclass SqliteDatabase:\r\n def __init__(self, *args, **kwargs) -> None: ...\r\n```\r\n\r\nand tested with: \r\n```\r\n$ MYPYPATH=stubs/ mypy combs.py\r\n``` \r\n\r\nAt the end it seems with can add a simple peewee `mypy` silencer to https://github.com/python/typeshed\r\n\r\n", "Static type check is great tool and like unit test and code coverage you don't have to check it all.\r\n\r\nSome kind of developers, like me, need all the help from tools that we can have.\r\n\r\nTo me type annotations is more useful than normal doc comments. It forces me to have them updated and follow type hints PEP 484 specs.\r\n\r\nPython dynamism is great for create flexible libs, frameworks and tools like `peewee`. But in everyday jobs too much flexibility could be a problem, Type-Driven Development help me to be centered on the task.\r\n", "@bySabi I think your problem is different than what we discussed here? You had:\r\n\r\n> ```\r\n> model/__init__.py:5: error: Cannot find module named 'peewee'\r\n> ```\r\n\r\nThat probably just tells that your (virtual)environment/PYTHONPATH is somehow messed up, because it's not finding `peewee` at all, thus giving errors also for stuff imported from it? You shouldn't be getting those errors in the first place.\r\n\r\nI don't think this issue can be handled through type stubs (`.pyi`s) as you still cannot provide different types for instance variable vs. class variable, something like `ClassInstanceVar` (see https://github.com/python/mypy/issues/1097 for discussion, there's also a hacky solution by @enomado).", "@tuukkamustonen it's possible that I missed something on `mypy` settings but virtual env is working fine when the project is runned.\r\n\r\nI think the problem with objects: SqliteDatabase, Model, IntergerField ... it's because they were imported using `from peewee import *` and that's why I could not apply `ignore_missing_imports` mypy setting on `peewee`. Lesson learned! : - )\r\n\r\nIn the end I could solve it using above `peewee.pyi` stub file.\r\n\r\nAnd your are right, my typing hint problem don't have nothing to do with this issue. But anyway annotate models with types IMO is lot of duplicate work cause peewee type Fields (IntergerField, CharField, ...) will do the typecheck/validation at runtime.\r\n\r\n\r\n\r\n\r\n\r\n\r\n", "I would also like to request this, because it helps with code completion.\r\n\r\nFor example, consider the code:\r\n\r\n my_user = User.select().first()\r\n\r\nThis returns a <Model: User>, but it would be great if it type hinted to a User object, because on the next line of code, I would get a list of functions available to user (for example, if the User class had a function ```user_function()```, I would see user_function() in the list of suggestions in the code completion hints. I know that I can specify this using # type: User, but I'd prefer it be automatic.\r\n\r\nAlso, is it possible to specify a return collection type? For example, in SQLAlchemy, I can do something like \r\n\r\n orders = relationship(\"Order\", back_populates=\"user\", collection_class=Orders) # type: Orders\r\n\r\nand the orders will be returned as an Orders object, which is a custom class object that inherits from InstrumentedList. This allows me to add special functions, such as .most_recent(), .to_df(), etc..." ]