Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "I didn't realize this broke with the latest changes, that sucks should've had a unit test in place to catch it. I'll look into it, but I'm thinking maybe I need to just scrap `AggregateQueryResultWrapper` and try a rewrite with some new ideas, it's becoming a bit of an eye-sore.\n", "Did you try `on=SomethingWithTwoDifferentThings.owner`, i.e. passing just the field object rather than using a boolean expression?\n", "Yeah, that's what I had initially, I put what I did above because I figured it was more implicit. Both ways yield the same error:\n\n```\nError\nTraceback (most recent call last):\n  File \"/Users/arrow/dev/test/peewee_test.py\", line 37, in test_load_my_stuff_please\n    .aggregate_rows())[0]\n  File \"/Users/arrow/dev/test/venv/lib/python2.7/site-packages/peewee.py\", line 2703, in __getitem__\n    res.fill_cache(index)\n  File \"/Users/arrow/dev/test/venv/lib/python2.7/site-packages/peewee.py\", line 1912, in fill_cache\n    self.next()\n  File \"/Users/arrow/dev/test/venv/lib/python2.7/site-packages/peewee.py\", line 1898, in next\n    obj = self.iterate()\n  File \"/Users/arrow/dev/test/venv/lib/python2.7/site-packages/peewee.py\", line 2197, in iterate\n    instance._data[metadata.src_fk.name]]\nKeyError: 2\n```\n", "I believe this one should now be fixed in master.\n" ]

[]

[]

[ "Shoot...be great if in the future the test-cases could use models in the existing tests, as much as I enjoy your 'bro' models lol.\n\nHave you tried using `prefetch` instead of `aggregate_rows()`? I think that there are enough complexities to `aggregate_rows()` that making it a general-purpose does-everything kind of method will require some rethinking from the ground-up.\n", "So this case is ambiguous and when using `aggregate_rows()` peewee assumes that you want the 1->N relationship, i.e. the category and all it's children, rather than the category and it's parent category.\n\nThat's kind of the point of using aggregate_rows() and is the reason I added this assumption. If you have a self-reference and want to get the parent, you can always write:\n\n``` python\n Grandparent = Category.alias()\n Parent = Category.alias()\n sq = (Category\n .select(Category, Parent, Grandparent)\n .join(Parent, on=(Category.parent == Parent.id))\n .join(Grandparent, on=(Parent.parent == Grandparent.id))\n .where(Grandparent.name == 'old granddaddy')\n .order_by(Category.name))\n for cat in sq:\n print cat.name, cat.parent.name, cat.parent.parent.name\n```\n", "I can see how this would be problematic if you have multiple joins though, i.e. you want to select the category and it's parent, but also some other objects that have a foreign key to category.\n", "In my actual use case I am eagerly loading a table that joins to a few other tables including one table that references itself, twice, as well as joining those self references with another table.\n\nSo it's a pretty complex query, haha. Loading data from several tables to be serialized to json is basically the crux of the project, though, and so `aggregate_rows()` was an important factor in choosing to use peewee =(\n\nThanks for the suggestion, though!\n", "Yeah, it's just a limitation right now of `aggregate_rows()` that when you have a self-referential join it will assume you want the 1->N relationship rather than the parent object. Have you tried using `prefetch()`? I feel like I've asked you that before a couple times.\n" ]

[]

[]

[ "There is no way to override the `is` lookup, so this won't work. Same thing for `not`, `and` and `or`.\n", "@coleifer Would adding something like `.equals(value)` or `.bool(value)` (to http://docs.peewee-orm.com/en/latest/peewee/querying.html#query-operators) be out of the question?", "I came across this issue because `autopep8` was breaking my queries to be pep8 compliant. For instance, my original query\r\n\r\n```python\r\nprofile_image = Image.select().where(\r\n (Image.organization == org_id) &\r\n (Image.user == None) &\r\n (Image.id == image_id)\r\n).get()\r\n```\r\nwas having its `== None` replaced with `is None`, becoming\r\n\r\n```python\r\nprofile_image = Image.select().where(\r\n (Image.organization == org_id) &\r\n (Image.user is None) &\r\n (Image.id == image_id)\r\n).get()\r\n```\r\nwhich led to a `peewee.DoesNotExist` error. I'm not sure if something like @tuukkamustonen's suggestion was ever implemented (I didn't find it), but <strike> an alternative would be to define a constant like\r\n\r\n\r\n```python\r\npeewee.NULL = None\r\n```\r\nso comparison to null values can be compared with `==` in a `pep8` compliant way.\r\n\r\nFor instance,\r\n\r\n```python\r\nprofile_image = Image.select().where(\r\n (Image.organization == org_id) &\r\n (Image.user == peewee.NULL) &\r\n (Image.id == image_id)\r\n).get()\r\n```\r\n\r\n</strike>\r\n\r\n**Update:** use @coleifer's solution below. \r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n", "To do null testing, use:\r\n\r\n```python\r\nImage.user.is_null(True)\r\n```\r\n\r\nOr\r\n\r\n```python\r\nImage.user.is_null(False) # IS NOT NULL\r\n```\r\n\r\nWhich is important because `IS NOT NULL` has different semantics than `NOT (... IS NULL)`." ]

[]

[]

[ "Well, actually if you look at the docs, this is now supported. I don't believe I've pushed those changes to PyPI yet, but they will be included in the next release.\n\n\n", "Oh nice @coleifer, making this issue has been on my todo list for months since you asked me to on IRC.\n" ]

[]

[]

[ "Well, I originally didn't want to add this, but thinking about it, enough people have requested this that maybe it'd be a good idea. Thanks I'll go ahead and add some tests.\n" ]

[]

[]

[ "Poking around the code, it's possible to get something like the Django flavor by having a new descriptor that just returns `_data[self.att_name]` and add it to the object during the `_new_()` call of `ForeignKeyField`\n", "This query will join `Post` and `User` and eagerly fetch the post's associated user object.\n\n``` python\nall_posts_with_user = Post.select(Post, User).join(User).execute()\n```\n\nThe other query you shared below will _not_ eagerly fetch the user, and will trigger a query when you attempt to access the `post.user` attribute.\n\n``` python\nall_posts = Post.select().execute()\n```\n\nAs you noted in your second comment, you can retrieve the related object's ID by looking at `post._data['user']`. Rather than modifying the code to add a new attribute, you can either subclass `ForeignKeyField` with your own implementation or write a `property` on your model class that will lookup the ID, e.g.\n\n``` python\nclass Post(Model):\n # ... fields ...\n @property\n def author_id(self):\n return self._data['author']\n```\n", "Yeah, eagerly was the wrong word to use - I meant that it fetched the entire object before it had to :)\n\nAnyway, thanks for merging it in! :)\n" ]

[]

[]

[ "`lsof` confirms that the app opens only a single connection to the database.\n", "This is getting stranger still. I have a different connection for every greenlet, and the low-level mysql code seems to create a new connection object to the database for each instance (as expected). However, `lsof` is showing only a single connection. \n\nIf I manually open two connections via `mysql.connect` using the python interpreter, `lsof` shows two connections.\n\nWhat am I missing here?\n\nBTW, we're running with `threadlocals=True`\n", "> If I read the code correctly, it's more of a maximum age after which a connection is closed no matter its usage, right?\n\nYes.\n\n> multi-greenlet application\n\nI have to think this is the issue / cause. Can you share the relevant parts of your code? Are you calling `gevent.monkey.patch_all()`, or are you being more selective?\n", "I'm just using gevent-socketio within gunicorn (both most recent). Gunicorn's gevent worker does the monkey patching: https://github.com/benoitc/gunicorn/blob/master/gunicorn/workers/ggevent.py#L61\n", "Ahh, actually I think this is the problem. In your code, the peewee module's instance of the `threading` module may not be patched at the time it is imported. This means that peewee's `Database` classes will use a `threading.local` instead of a _greenlet local_.\n\nTo fix this, in your WSGI script or the entry point of your application, at the very top of the module, first import, try adding:\n\n``` python\nfrom gevent import monkey; monkey.patch_all()\n```\n\nLet me know if that fixes the issue.\n", "I've worked many hours on playhouse. It needs many cares to continue\ndeveloping. Close all connection does not work correctly because of Id of\nresource not representing original mysql connection. To see MySQL\nconnections run command \"show full processlist;\"\nCertainly some connections are created with pool but are not closed with\nit. It means some connections stay in _in_use or don't close correctly! See\nsleep times in process list of MySQL. I'm using gevent pool for some tasks\nwith peewee and this is my observation. Configure your MySQL to close sleep\nconnections with more than some certain time .e.g 200 seconds. Playhouse\npicks up one connection from pool for each thread and if no connection is\navailable new connection will be created.\nOn May 21, 2015 6:31 PM, \"Charles Leifer\" [email protected] wrote:\n\n> Ahh, actually I think this is the problem. In your code, the peewee\n> module's instance of the threading module may not be patched at the time\n> it is imported. This means that peewee's Database classes will use a\n> threading.local instead of a _greenlet local_.\n> \n> To fix this, in your WSGI script or the entry point of your application,\n> at the very top of the module, first import, try adding:\n> \n> from gevent import monkey; monkey.patch_all()\n> \n> Let me know if that fixes the issue.\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/608#issuecomment-104286302.\n", "Can't do, if I add `patch_all` to the WSGI script, the worker doesn't start at all with the most recent gunicorn 19.x. (We had `patch_all` in our WSGI script in a previous version.)\n", "@arnuschky maybe `patch_thread` then instead?\n", "@emamirazavi, sorry to hear you're having issues with the pool module. The module is unit-tested extensively (378 lines of tests compared to 185 of the module itself). It is also quite simple from an implementation standpoint. I'm inclined to believe that these bugs may be at the application level and not in peewee or the pool (especially because you mentioned using gevent and that requires some care to get right). If you can provide me a test-case showing otherwise that would be great.\n", "@coleifer, thank you, that did the trick! It's now creating multiple real connections to the db.\n\nIt remains that the `_in_use` dictionary never shrinks, but this might be now due to my code. Peewee is creating many connections for a single socket of gevent-socketio: one for the request, one for the main greenlet, and then one for each greenlet that I launch. My problem is that I have troubles terminating all of them properly once the socket closes.\n\nIs it somehow possible to share a database connection among several greenlets, even when running with threadlocals? This all-or-nothing sharing is a bit limiting in my case...\n", "I can confirm that connections are now properly removed from `_in_use` on close; it's just the combination of Peewee, gevent-socketio, and my code that causes only a single connection to be properly closed while the others linger.\n\nTo repeat my question above: is it somehow possible to share a database connection among several greenlets, even when running with threadlocals? This all-or-nothing sharing is a bit limiting in my case.\n", "> Is it somehow possible to share a database connection among several greenlets, even when running with threadlocals? This all-or-nothing sharing is a bit limiting in my case...\n\nNot easily, no, though I'm not sure why you'd want to. The main greenlet really shouldn't need a connection unless of course you're making queries from it. I obviously don't know anything about your code or your app, so it's hard for me to speculate.\n\n> It remains that the _in_use dictionary never shrinks, but this might be now due to my code.\n\nThe `_in_use` should grow when you open a connection and shrink when you close one. The fact that you're using socketio may have something to do with the odd behavior, but I really don't know.\n\nI really like gevent, but unfortunately you need to know something of the implementation to reason about its behavior.\n\nI'm closing this issue as invalid, since the problem was monkey-patches not being applied correctly during import time, and this isn't an issue with peewee.\n", "> To repeat my question above: is it somehow possible to share a database connection among several greenlets, even when running with threadlocals? This all-or-nothing sharing is a bit limiting in my case.\n\nAgain, I'm not sure how your app works, or when you are opening/closing connections, or the interaction between the socketio greenlets and the rest of the app.\n\nIn a typical web app (using gevent or otherwise), peewee stores the conn on a threadlocal (or greenlet-local). Additionally, typical web apps will spawn a thread or greenlet to handle each request. So request comes in to server, server spawns thread/greenlet, app opens connection and generates HTTP response, app closes DB connection after sending response, server shuts down greenlet. Socketio adds another layer of complexity and I'm just not familiar with it.\n", "Ok, thank you for your answers. \n\nTo rephrase my last question more precisely: currently, when using threadlocals, Peewee automatically creates a new connection when I call `connect()` on my Peewee db object. So whenever I use Peewee with multiple greenlets, Peewee always creates a new connection for each greenlet. To get around this, my only choice is to pass around an already connected instance of my database object, right?\n", "> currently, when using threadlocals, Peewee automatically creates a new connection when I call connect()\n\nYes, that is the correct behavior. If you are using a pool, then the connections will be managed by the pool, but the drift of your statement is correct. If you're using the pool, only `max_connections` will be opened.\n\n> To get around this, my only choice is to pass around an already connected instance of my database object, right?\n\nWait, I thought you were using the connection pool because you _wanted_ multiple connections? I'm confused... What exactly do you want?\n", "Every thread has its own connection. You must have one connection for each\nthread. Thread local brings you this ability. Each time you call connect in\npool mode, one ready connection from pool will be returned to you or if no\nconnection exists, new connection will be created and will be returned.\nOn May 21, 2015 10:17 PM, \"Charles Leifer\" [email protected] wrote:\n\n> currently, when using threadlocals, Peewee automatically creates a new\n> connection when I call connect()\n> \n> Yes, that is the correct behavior. If you are using a pool, then the\n> connections will be managed by the pool, but the drift of your statement is\n> correct. If you're using the pool, only max_connections will be opened.\n> \n> To get around this, my only choice is to pass around an already connected\n> instance of my database object, right?\n> \n> Wait, I thought you were using the connection pool because you _wanted_\n> multiple connections? I'm confused... What exactly do you want?\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/608#issuecomment-104369523.\n", "I'm using Flask, Gunicorn and Gevent thread pool. I'm just closing\nconnection on flask tears down, because pooling automatically open one\nconnection. My problem is that sometimes one connection in pool stay with\nno assignment and count of this [sleep] connections up to 150 after a day!\nConnection in playhouse.pool just is saved in thread local, and in use or\nconnections properties don't know MySQL connection resource to handle\nconnection correctly. I should tell that this observation read after\ninstalling Gunicorn and running my app as a preloaded application. Any\nideas?\n", "> You must have one connection for each\n> thread.\n\nIf you specify `threadlocals=False` when initializing your database then this is not true, one conn will be shared.\n", "What I want is basically this: each socket worker (which is a greenlet) has a single connection which is shared with its sub-greenlets.\n\nWhat I have is that my app sets up a new db connection before the request, as usual. However, this happens in the main gunicorn worker and not the socket worker greenlet. Hence, there's a new connection for the socket greenlet, which starts a few sub-greenlets that each get a new db instance as well. Closing connections later is even more messy depending on whether there was an exception and in which greenlet it occurred.\n\nThe first problem with the app creating a new connection is easy enough to fix but the second is harder: how can the sub-greenlets share a single connection with their parent, the socket greenlet?\n", "I think you will have to write your own connection management code in this case, since it's rather unique.\n", "It seems so. :) Thanks for all your help!\n" ]

[]

[]

[ "Nice catch, thanks!\n" ]

[]

[]

[ "Can you provide a test-case that shows the broken behavior?\n", "``` python\nfrom peewee import *\nfrom unittest import TestCase\n\ndb = SqliteDatabase(':memory:')\n\n\nclass SomethingThatReferencesItself(Model):\n name = CharField()\n bro = ForeignKeyField('self', null=True, related_name='bros')\n\n class Meta:\n database = db\n\n\nclass EagerLoadSelfReferencingJoinPleaseYesOkay(TestCase):\n @classmethod\n def setUpClass(cls):\n SomethingThatReferencesItself.create_table()\n bob = SomethingThatReferencesItself.create(name='bob')\n SomethingThatReferencesItself.create(name='joe', bro=bob)\n SomethingThatReferencesItself.create(name='rofl guy', bro=bob)\n\n def test_get_aggregate_bro(self):\n Bro = SomethingThatReferencesItself.alias()\n\n joe = (SomethingThatReferencesItself\n .select(SomethingThatReferencesItself, Bro)\n .join(Bro, on=(SomethingThatReferencesItself.bro == Bro.id).alias('bro'))\n .where(SomethingThatReferencesItself.name == 'joe')\n .aggregate_rows()\n .get())\n\n self.assertIn('bro', joe._obj_cache)\n self.assertEqual(joe._obj_cache['bro'].name, 'bob')\n```\n\nI'm using Model._obj_cache to verify that the data was eagerly loaded. Because ModelOptions.rel_for_model does not support joining via ModelAlias, this will not work.\n\nI'm not aware of a way to eagerly load a parent with its children using a self-referencing join, for example, loading the above bob with his bros, but you're the master so perhaps you'd know how to write/test that.\n", "Hmm, I think the fix for this may be more involved. I'm seeing some issues when self-references are queried using either `prefetch` or `aggregate_rows`. &lambda;\n", "Added support for self-joins in `prefetch` in 499bf2e81e66173eb4c50c5436ec43e88cbeb96b. Just need to get `aggregate_rows()` fixed now.\n", "Awesome work! Looking forward to the next release! As you can tell, I use `aggregate_rows` a lot =P\n", "@arrowgamer not quite fixed yet, still need to get the `aggregate_rows()` bit working. Also just FWIW don't mix calls to `aggregate_rows()` with `.get()`.\n", "@coleifer Yes, I saw your commit was only for `prefetch`. I assume by next release you'll have it wrapped up? :laughing: And I'm aware of what `.get()` does to `aggregate_rows()` via `LIMIT`. Normally I use `SelectQuery[0]` in place of it when expecting more than one result returned from a join. Is there another way?\n", "So from e5ce2bdf71f19bd5d4f8ab87b461bc23dea49da1 I think that the basic use-case should now work. Honestly due to the complexity of the `aggregate_rows()` implementation, plus mixing in `ModelAlias`, I don't know how much more I can do here.\n", "So what would be the syntax of using `aggregate_rows()` to load a parent with its children or, using the above example, load a record with its bros?\n\nEdit: Nevermind, took a look at your testcase =) Thanks!\n", "The example test case shows, but say you have `Category` which has a foreign key like so:\n\n``` python\nclass Category(Model):\n name = CharField()\n parent = ForeignKeyField('self', related_name='children')\n```\n\nYou would write:\n\n``` python\nChild = Category.alias()\nquery = (Category\n .select(Category, Child)\n .join(Child, JOIN.LEFT_OUTER, on=(Category.id == Child.parent).alias('kids'))\n .order_by(Category.id, Child.id)\n .aggregate_rows())\nfor category in query:\n print category.name\n for child in category.kids:\n print ' -', child.name\n```\n\nA caveat is that you must specify an alias in the join condition.\n", "Thanks a bunch for the explanation! Once released, I'll report any issues if I find any, as I'm already using aggregated self-referencing joins.\n" ]

[]

[]

[ "Hmm...while I can see the benefit of allowing operations to map to callables, I do not have plans to add that currently. You can always subclass `QueryCompiler` and provide your own implementation for `_parse_expression` that does the right thing.\n" ]

[]

[]

[ "Have you tried telling the pool to close all connections in the error handler? This might work better:\n\n``` python\n def sql_error_handler(self, exception, sql, params, require_commit):\n\n if isinstance(exception, pymysql.err.OperationalError):\n\n if exception.args[0] in self.CONN_FAILURE_CODES:\n db.close_all() # Changed this line from `manual_close()`.\n\n return True\n```\n", "I didn't try that, but while it would \"heal\" all the other connections, this one request would still fail (per process). It might not sound much, but...\n\nI also wonder: would `close_all()` really close all of the connections, even those in active use at the point of time in other threads, causing them to fail their requests?\n\nWell, I assume it doesn't matter as they would fail anyway (as the connections are broken).\n", "> I also wonder: would close_all() really close all of the connections, even those in active use at the point of time in other threads, causing them to fail their requests?\n\nNo, those connections would not be closed and presumably they'd fail with the same `OperationalError`.\n", "I think the `close_all()` solution is as good as it gets, so I'm going to close this for now.\n", "@coleifer So, it's not possible to allow returning a new cursor? Would it be too complex, technically?\n", "Yeah, returning the new cursor is the crux of the issue. I'm not sure of the cleanest way to do that with `sql_error_handler()`. I'd prefer not to break existing implementations, but at the same time I think it's failing to do what I had designed it for in the first place.\n\nI think I'll see about reworking the method.\n", "I'm not positive of all the conditions that might cause an `OperationalError`, but I can imagine a max-recursion issue if the `connect()` after `close()` succeeded, and the subsequent `execute_sql()` raise an `OperationalError`:\n- `execute_sql(...)`\n- `OperationalError` occurs\n- call `sql_error_handler()`\n - `db.close()`\n - `db.connect()` - let's assume this succeeds\n - `db.execute_sql(...)` - retry the query\n - `OperationalError` occurs\n - call `sql_error_handler()` ...\n\nYou get the drift... If the issue was the db being unavailable this wouldn't be the case as the `connect()` would fail, but perhaps there are other reasons an `OperationalError` might be raised?\n", "The more I think about it, the more I'm thinking that if the query fails with an `OperationalError`, it probably doesn't make sense to immediately retry. **Unless** you're using a connection pool, and there's a possibility the connection you just checked out is stale and all you need to do is reconnect to be good to go... Hmm...\n", "I agree, this sort of re-connection logic makes sense only when using connection pooling. And even then, finding out all the situations where a re-connection might help (and not cause side effects) could be tricky... or not. I'm no expert with MySQL - the two failure codes (`2006`, `2013`) were just my first findings when I bumped into this issue.\n\nRegarding stale connections, I was in the assumption that `connect()` (which I'm calling for each requests) actually ensures that connection is not stale (and closes + opens a new one if it is). Or does that logic apply to just `stale_timeout`?\n\nI didn't realize the recursion issue. Wouldn't it be possible to catch that with a counter (or simply allow single retry)?\n\nThen, after thinking about this more, I don't think this is as critical as I initially thought. I mean, if the database is down for a moment, the milk is already spoiled, some requests will fail anyway. It doesn't make big difference if couple of requests fail even after DB is back up. `close_all()` helps a lot.\n\n(Though I would wish that was built-in to the pool somehow.)\n\nThe most annoying scenario is when DB temporarily goes away and comes back without any requests being processed between. As in my original post: _each open connection would break for DB going down temporarily, even if those connections were not used during the downtime._ That would mean a couple of failing requests, where in perfect world none would fail. I assume it's not that bad, either.\n", "> Regarding stale connections, I was in the assumption that connect() (which I'm calling for each requests) actually ensures that connection is not stale (and closes + opens a new one if it is). Or does that logic apply to just stale_timeout?\n\nWhen a connection is checked out, it first checks if the connection is stale, and if not, it will check if the connection \"is closed\" by calling the `_is_closed()` method. The MySQL implementation looks like this:\n\n``` python\n def _is_closed(self, key, conn):\n is_closed = super(PooledMySQLDatabase, self)._is_closed(key, conn)\n if not is_closed:\n if hasattr(conn, 'open'):\n # MySQLdb `ping()` seems to always return `None` in my testing.\n # So the `open` attribute will be used instead.\n is_closed = not bool(conn.open)\n else:\n # pymysql `ping([reconnect=True])` will indicate if the conn\n # is closed or not.\n try:\n is_closed = not conn.ping(False)\n except:\n is_closed = True\n return is_closed\n```\n\nAs to the case where the connection goes away then comes back, I would have thought the logic in `_is_closed()` would catch those. Maybe something isn't working as I had thought?\n", "What I did was simply restart MySQL (an AWS RDS instance) and throw in requests after it was back up. It was a master-standby setup, but I didn't really activate failover to standy - it was the same master going down and back up again. Of course, there's always also possibility of AWS RDS doing interesting things compared to simpler, local MySQL installation. Give me couple of days and I'll verify the behavior when I'm back at the office.\n\n> As to the case where the connection goes away then comes back, I would have thought the logic in _is_closed() would catch those. Maybe something isn't working as I had thought?\n\nLooking at pymysql's `ping()`, if `socket` exists, `pymysql` will ping the DB, and if that doesn't work, exception is thrown and peewee's `_is_closed()` will return `True` as expected.\n\nWhat makes me wonder, is pymysql's `Connection.open`:\n\n```\n@property\ndef open(self):\n return self.socket is not None\n```\n\nAs peewee relies solely on this (when available), maybe in some scenarios the socket _exists_, but it's actually in a failed state and actual operations will fail? Is `open` proper way to check the health of the connection?\n", "Ok I tested it locally:\n- start app\n- make some requests to fill the connection pool\n- stop mysql\n- start mysql (no requests during downtime)\n- make a request\n\nThe result is:\n\n```\n File \"/home/musttu/Code/virtualenvs/cs/local/lib/python2.7/site-packages/pymysql/connections.py\", line 916, in _write_bytes\n raise err.OperationalError(2006, \"MySQL server has gone away (%r)\" % (e,))\n```\n\nI took a look at pymysql's `Connection.open` and indeed it returns `True` even after mysql restart. So I assume socket does not get closed, because it is not explicitly instructed to be closed by the driver.\n\nA quick googling gave me: http://stackoverflow.com/questions/3335342/how-to-check-if-a-mysql-connection-is-closed-in-python which actually states the same.\n\nUnfortunately, it doesn't sound like there is a way to directly know if the connection is functional or not. The expert there suggests a try/except block, which to me sounds like either failing that single request and callling `close_all()` (to play safe) or doing some sort of a retry logic.\n\nOf course, if pool always pinged the database, broken connections would be caught, but yeah that would also introduce latency, waste IO and such.\n", "Thanks for looking into it some more. Well, I guess there's not much to do here. If you wanted to subclass the pool and modify the `_is_closed()` method to PING that'd be one option.\n", "I agree, this is a corner case anyway and `close_all()` is good enough. Thanks for reviewing it.\n", "In case you're interested, I've got a mixin for retrying failed queries in 017e4e4952f0b429dd21f0e90465a0f644cf6015 . Docs:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/database.html#automatic-reconnect\n" ]

[]

[]

[ "Doh, Found it in the closed issues. Sorry.\n" ]

[]

[]

[ "You can probably build something _on top_ of peewee, but peewee itself does not support table partitioning.\n\nIf you want to change the table your query uses at run-time, you can set the `ModelClass._meta.db_table` attribute, e.g.\n\n``` python\nAccount._meta.db_table = 'account_123'\nquery = Account.select().where(Account.username == 'username_xxx')\nAccount._meta.db_table = 'account'\n```\n\nYou could write a context manager, for example:\n\n``` python\nwith Account.query_partition(123):\n query = Account.select().where(...)\n```\n", "One potential solution that we're looking at: http://architect.readthedocs.io/features/partition/index.html\n" ]

[]

[]

[ "Nice idea, be happy to add that.\n", "Wow, thanks for such a quick response. That solution is awesome!\n" ]

[]

[]

[ "Well, let's say you have `User` and `Tweet` from the docs:\r\n\r\n``` python\r\nclass User(Model):\r\n username = CharField(unique=True)\r\n\r\nclass Tweet(Model):\r\n user = ForeignKeyField(User, related_name='tweets')\r\n content = TextField()\r\n timestamp = DateTimeField(default=datetime.datetime.now)\r\n```\r\n\r\nYou can observe that the `user.tweets` object is a `SelectQuery`:\r\n\r\n``` python\r\n>>> u = User.create(username='charlie')\r\n>>> u.tweets\r\n<class '__main__.Tweet'> SELECT \"t1\".\"id\", \"t1\".\"user_id\", \"t1\".\"content\", \"t1\".\"timestamp\" FROM \"tweet\" AS t1 WHERE (\"t1\".\"user_id\" = ?) [1]\r\n```\r\n\r\nSince it's just a query you can call `order_by()` on it:\r\n\r\n``` python\r\n>>> u.tweets.order_by(Tweet.timestamp.desc())\r\n<class '__main__.Tweet'> SELECT \"t1\".\"id\", \"t1\".\"user_id\", \"t1\".\"content\", \"t1\".\"timestamp\" FROM \"tweet\" AS t1 WHERE (\"t1\".\"user_id\" = ?) ORDER BY \"t1\".\"timestamp\" DESC [1]\r\n```\r\n\r\nIf you don't want to type this all the time, just create a `property` object on `User`:\r\n\r\n``` python\r\nclass User(Model):\r\n # ... fields ...\r\n\r\n @property\r\n def tweets_ordered(self):\r\n return self.tweets.order_by(Tweet.timestamp.desc())\r\n```\r\n\r\nThen use `tweets_ordered`.\r\n", "The property solution is slick. Thanks!\n", "@coleifer then how do you call `tweets_ordered`? since it would belong to User?\r\nIt must be `u.tweets_ordered` , but `tweets_ordered` is a property of Tweet?", "I had made a mistake, that should have read class User. I've edited the comment. Hope that helps." ]

[]

[]

[ "Actually, I think this is acceptable behavior. It wouldn't be hard to use a second attribute to store instance-specific overrides and merge them when instantiating the `QueryCompiler`, but I think this is OK as-is.\n" ]

[]

[]

[ "No they are not run for MySQL because there are some failures that I do not intend to fix. MySQL is supported, and most things work, but it is not tested as part of the continuous integration.\n" ]

[]

[]

[ "Thank you!\n" ]

[]

[]

[ "That's a neat idea, but I'm not sure how to implement that without cluttering up the `ForeignKeyField` / `RelationDescriptor` classes.\n\nOne thing you can do currently, which is very easy, is to use the `assert_query_count` helper in `playhouse.test_utils` ([documentation link](http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#assert_query_count)):\n\n``` python\nclass TestMyApp(unittest.TestCase):\n @assert_query_count(1)\n def test_get_popular_blogs(self):\n popular_blogs = Blog.get_popular()\n self.assertEqual(\n [blog.title for blog in popular_blogs],\n [\"Peewee's Playhouse!\", \"All About Huey\", \"Mickey's Adventures\"])\n\n def test_expensive_operation(self):\n with assert_query_count(1):\n perform_expensive_operation()\n```\n\nI think these are probably a better way of ensuring correct query behavior than checking for accidental foreign key resolutions anyways.\n" ]

[]

[]

[ "Without a little more info I have no idea what to do with this.\n\nNext time take the two extra seconds to format your issue at least.\n" ]

[]

[]

[ "This is not at all a peewee bug. You just forgot that if you want a tuple with one element you need a trailing comma:\n\n``` python\n class Meta:\n indexes = (\n (('something', 'name'), True), # Added trailing comma.\n )\n```\n", "D'oh! I learn something new every day. Thanks for the tip.\n" ]

[]

[]

[ "No. You can muck around with `SelectQuery._select`, which is a list of the selected columns. Even better is to just use the `SelectQuery.select()` method to modify the list of columns.\n", "Ok , fair enough\n\nOn Wed, May 6, 2015 at 11:46 AM, Charles Leifer [email protected]\nwrote:\n\n> Closed #593 https://github.com/coleifer/peewee/issues/593.\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/593#event-298363133.\n" ]

[]

[]

[ "Yeah, I haven't issued a new release yet.\n", "Anyway great thing hybrid properties,thx\n\nOn Tue, May 5, 2015 at 1:37 PM, Charles Leifer [email protected]\nwrote:\n\n> Closed #592 https://github.com/coleifer/peewee/issues/592.\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/592#event-297451694.\n" ]

[]

[]

[ "Interesting, what version of psycopg2 are you using?\n", "missed my environment\nubuntu 14.04\npython 2.7.6\npsycopg2 is 2.4.5 from python-psycopg2 package\n\nIt could be this situation.\n\n```\nimport psycopg2\n\nname = None\nconnection = psycopg2.connect('dbname=test user=test')\ncursor = connection.cursor(name=name)\n```\n\n```\nTraceback (most recent call last):\n File \"test.py\", line 5, in <module>\n cursor = connection.cursor(name=name)\nTypeError: argument 1 must be string, not None\n```\n", "Ew, just a tip but you should definitely be using pip and not the Ubuntu psycpog2 package.\n\nThat said, seems like a fine PR so I'll go ahead and merge.\n" ]

[]

[]

[]

[]

[]

[ "I prefer to keep model creation APIs as-is. Of course if you like using this function to create tables at module-load time then you could release it as a peewee extension. I prefer to avoid any import-time side-effects and APIs that promote them.\n", "Thanks for the feedback. But what about the first part of the patch regarding auto-closing MySQL connections?\nPatch for 911833b1b08a44041cf99cdc76117adec1a6832b\n\n```\n3473a3474,3479\n> def execute_sql(self, sql, params=None, require_commit=True):\n> \"\"\"Executes an SQL query with an explicit connection\"\"\"\n> with self.execution_context():\n> return super(MySQLDatabase, self).execute_sql(\n> sql, params=params, require_commit=require_commit)\n> \n```\n" ]

[]

[]

[ "Peewee is currently at 2.6.0, and this code runs correctly under 2.6.0, so I'm not sure what more I can tell you besides _upgrade_! :)\n", "Ok, this is strange. I tested it in Ubuntu 15.04 and Windows 8.1 VMs and it works. But I can reproduce the error every time on my system in both python2 and python3.\n\npeewee==2.4.2 works\npeewee==2.4.3 error\npeewee==2.6.0 error\n\nI'm using Mac OS X 10.10.3\nSQLite 3.8.9, Python 3.4.3 installed with homebrew.\n\nDo you have any idea how to investigate this?\n", "Are you sure about 2.6.0 being broken? With peewee 2.6.0, python 2 or 3, and sqlite 3.8.9 the script works as expected:\n\n``` python\nfrom peewee import *\nfrom peewee import create_model_tables\nfrom playhouse.migrate import SqliteMigrator, migrate\n\ndb = SqliteDatabase(':memory:')\n\nclass Measurement(Model):\n some_field = CharField(index=True)\n\n class Meta:\n database = db\n\ncreate_model_tables([Measurement])\n\nmigrator = SqliteMigrator(db)\nmigrate(\n migrator.add_column('measurement', 'location', CharField(default=''))\n)\n\nprint(db.get_columns('measurement'))\n```\n\nOutput:\n\n``` python\n[\n ColumnMetadata(name='id', data_type='INTEGER', null=False, primary_key=True, table='measurement'), \n ColumnMetadata(name='some_field', data_type='VARCHAR(255)', null=False, primary_key=False, table='measurement'), \n ColumnMetadata(name='location', data_type='VARCHAR(255)', null=False, primary_key=False, table='measurement')]\n```\n", "If you're running the above \"test\" script you might also add something like the following, just to be sure:\n\n``` python\nfrom peewee import __version__ as peewee_version\nprint('Peewee version %s' % peewee_version)\n```\n", "This returns:\n\n```\nPeewee version 2.6.0\nTraceback (most recent call last):\n File \"test 2.py\", line 22, in <module>\n migrator.add_column('measurement', 'location', CharField(default=''))\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 575, in migrate\n operation.run()\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 144, in run\n getattr(self.migrator, self.method)(*self.args, **kwargs))\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 138, in _handle_result\n self._handle_result(item)\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 135, in _handle_result\n result.run()\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 144, in run\n getattr(self.migrator, self.method)(*self.args, **kwargs))\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 135, in _handle_result\n result.run()\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 144, in run\n getattr(self.migrator, self.method)(*self.args, **kwargs))\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 152, in inner\n return fn(self, *args, **kwargs)\n File \"/usr/local/lib/python3.4/site-packages/playhouse/migrate.py\", line 449, in _update_column\n indexes = self.database.get_indexes(table)\n File \"/usr/local/lib/python3.4/site-packages/peewee.py\", line 3184, in get_indexes\n for _, name, is_unique in cursor.fetchall():\nValueError: too many values to unpack (expected 3)\n```\n\nIf I set `index=False`, it works as expected.\n", "Ahh, I think this is due to changes in SQLite. This was just recently fixed in:\n\n6d616e25c9748abc22ecf3f413b81ee91c390699\n\nSo you might try out master for now until I release 2.6.1.\n", "Thank you for the feedback, I thought there was something wrong with my system :+1: \n" ]

[]

[]

[]

[]

[]

[ "Classmethods operate on the table. Instance methods operate on the rows. Class represents table, instance represents row. It is just an inconvenient fact of python's `classmethod` decorator that you can call classmethods from an instance. I could write a special decorator that prevented this, e.g. `classonlymethod` but I don't think it's worth the time and more Pythonic anyways.\n", "That makes sense, I had considered using a special decorator myself in the past but it always felt like a bit too much magic, and made it confusing for anyone new to the code. This has given me some food for thought anyway, thanks again for the quick reply.\n" ]

[]

[]

[ "The correct way is to write:\n\n``` python\nconnect('sqlite:///:memory:')\n```\n", "Doh, you are correct. Confirmed working, my apologies.\n" ]

[]

[]

[ "Glad you're enjoying using peewee!\n" ]

[]

[]

[ "Extending the discussion from #582, I was unable to find a clean way to introduce module inspection into Peewee without also bringing in the concept of 'apps', which is way outside of its scope as an ORM.\n\nThe cleanest way I've found so far is to use a connection manager by wrapping each connection with a proxy and referencing it later on. The test case can then tell the database proxy to switch out the current connection for the test database connection.\n\nHowever this breaks because `create_model_tables()` also requires models to be defined explicitly, and due to module inspection not being a clean way forward, the next alternative would be to maintain some sort of global registry of models. This could perhaps be achieved by using the `BaseClass` metaclass to place itself into a list on the peewee module.\n\nFurther more, `create_model_tables()` is unable to distinguish which classes are \"base inheritance\" classes, e.g. used by other models but not actually a model themselves. The best option I can think of would be to introduce a new meta option called `abstract`, similar to the one in [Django](1), which would prevent this problem from happening.\n\nNaturally this would be quite a big change but none of these would be backwards incompatible. The proposal so far would be for;\n- Database router\n- Connection manager\n- Models registry\n- New meta option `abstract`\n", "In order to keep peewee simple I have chosen not to implement this type of functionality. The database is simply an attribute on the `Model._meta` object, so tooling could be built to change this at run-time, but at no point do I think peewee will include routers/connection managers like Django for example.\n", "Thanks for the quick reply, appreciated.\n" ]

[]

[]

[ "As a temporary workaround, I was able to do the following;\n\n``` py\nimport unittest\nimport inspect\nimport models\nimport peewee\nfrom app import testdb\nfrom playhouse.test_utils import test_database\n\nclass PeeweeTestDatabaseMixin(object):\n def run(self, *args, **kwargs):\n classes = [ v for k,v in inspect.getmembers(models, inspect.isclass) \n if issubclass(v, peewee.Model) ]\n test_database(testdb, classes)\n return super(PeeweeTestDatabaseMixin, self).run(*args, **kwargs)\n```\n", "I prefer keeping things explicit as it is easier to understand and the implementation is simpler.\n" ]

[]

[]

[ "In the mean time, for anyone who comes across this problem in the future, I was able to get a temporary monkeypatch working;\n\n``` py\nfrom playhouse import db_url\nfrom playhouse.pool import PooledMySQLDatabase\ndb_url.schemes['mysql'] = PooledMySQLDatabase\n```\n\nThe above will replace the MySQL backend with a pooled backend, whenever `connect()` is used. Replace classes accordingly for other databases, see [here](1).\n", "You can use `db_url.parse(url)` to parse the data into a dictionary, then pass the dictionary values into a pooled database implementation. Because pooled databases require additional arguments (pool size, etc), they do not seem to me a good candidate for inclusion in the db_url module.\n", "That works beautifully, thank you.\n" ]

[]

[]

[ "I have no plans myself for adding support for any MySQL-specific features since between Postgres and SQLite I never find myself using MySQL. That said, I would certainly be open to a well-tested pull-request (with documentation).\n", "Thanks for the quick reply, if I end up using MariaDB JSON heavily then I'll put together a PR.\n" ]

[]

[]

[]

[]

[]

[ "I can see the reasoning behind this change, but I'm loth to introduce any changes that might break existing applications. I'm not sure off-hand, but given the way peewee munges `Meta` objects at present, there may be some edge-cases or situations where this breaks.\n\nWhat do you think?\n", "I see, the `dir()` function may be unstable.\nCan we use `inspect.getmembers()` instead? \nhttp://stackoverflow.com/a/8529470/2815178\nI think it's more safety.\n\n``` python\nimport inspect\nfor k, v in inspect.getmembers(meta):\n if not k.startswith('_'):\n meta_options[k] = v\n```\n", "Or I can just use a decorator:\n\n``` python\ndef with_database(cls):\n cls.database = db\n return cls\n\n\nclass BaseModel(Model):\n @with_database\n class Meta:\n pass\n\nclass ModelA(Model): \n pass\n\nclass ModelB(Model):\n @with_database\n class Meta:\n db_table = \"model_b\"\n```\n\nThen, nothing need changes in Peewee.\nIt's just not so nature.\n", "You do know you can write this, right?\n\n``` python\ndb = PostgresqlDatabase(\"mydb\")\n\nclass BaseModel(Model):\n class Meta:\n database = db\n\nclass ModelA(BaseModel): \n # no need to define Meta / database = db, it is inherited.\n pass\n\nclass ModelB(BaseModel):\n class Meta(BaseMeta):\n # database = db --> this is inherited via BaseModel\n db_table = \"model_b\"\n```\n", "Oh, I don't know this before. Thank you!\nPerhaps this pull request is not needed any more?\n" ]

[]

[]

[ "Sorry, I think this was a database issue, peewee was just passing back the error.\n" ]

[]

[]

[ "thnx porco rosso\n" ]

[]

[]

[ "I'm not sure I understand what is happening. Can you share code to replicate the issue?\n", "I feel sorry for disturbing you. It is not issue of peewee itself, it was at DB level...\n" ]

[]

[]

[ "Thanks!\n", "Thank you! Can I hope on patch-release?\n", "I'll probably wait a bit as I just released a new one not long ago. Maybe a couple weeks?\n", "Up to you. But for now I have to use manual installation from github, it's not compatible.\n", "I just released 2.6.0.\n", "Great! Thank you!\n" ]

[]

[]

[ "i find define of LTreeFiled in peewee old version - 0.9.9 , why delete this logic in lastest version ?\n", "> from the docs we can know peewee ext can support postgres ltree\n\nWhere in the docs does it say this?\n", "I have no intentions of adding LTree back, but would accept pull-requests.\n" ]

[]

[]

[ "Hey, if you are using the `PostgresqlExtDatabase` you can use `cls.created_at.cast('text') ** format`.\n\nHonestly why on earth are you doing your date comparison like that, though?! You can use the `between()` function, `fn.date_trunc()`, so many alternatives.\n\nFor example, I believe this should work:\n\n``` python\n@classmethod\ndef get_blog_by_date(cls, year, month):\n return cls.select(cls.created_at).where(\n fn.date_trunc('month', cls.created_at) == datetime.date(year, month, 1))\n```\n" ]

[]

[]

[ "I think I will pass on making changes to the implementation. The method has been deprecated for some time and there is documentation on implementing it yourself:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/querying.html#get-or-create\n", "These changes are now included in the new version 2.6.0. The function behaves just like it's Django equivalent.\n", "Cool!\n" ]

[]

[]

[ "``` python\nus_pub = Publisher.select().where(Publisher.country == 'US')\nBook.update(foo='bar').where(Book.publisher << us_pub)\n```\n\nIIRC only MySQL supports joins on update queries, while SQLite and Postgres do not. Subqueries are the way to go.\n", "aha! thanks for the quick reply.\n", "actually, what if i wanted to populatw my books with some value\nfrom the related publisher.. No way to do that i guess?\n", "If you're using postgres you can theoretically use `update({Book.foo: Publisher.bar}).from_(Publisher)`", "@GothAck is correct, and this is supported by peewee. Sqlite will be adding support for this in the next release as well, which is exciting.\r\n\r\nExample peewee usage:\r\n\r\nhttps://github.com/coleifer/peewee/blob/611a08987e8f08af1056ec679ea6cfdccb87c65b/tests/model_sql.py#L689-L743" ]

[]

[]

[ "Nice! Do you mind adding a test-case for the new function?\n", "Sure, :+1: ?\n", "Thanks!\n" ]

[]

[]

[ "The problem is that peewee assumes when it encounters a Model as part of a query, that it should alias it to the alias used for that table. In this case, however, we don't want that -- we simply want the table name to be passed in.\n\nTo remedy, you can rewrite this as:\n\n``` python\nfrom peewee import Entity\n(FTSBook\n .select(fn.snippet(Entity(FTSBook._meta.db_table)))\n .where(FTSBook.match('python')))\n```\n\nIf you are using peewee 2.5.0 or older, you can also use:\n\n``` python\n(FTSBook\n .select(fn.snippet(FTSBook._as_entity()))\n .where(FTSBook.match('python')))\n```\n\nFinally, if you are using master, I changed `_as_entity()` to a public method, so it is now `as_entity()`:\n\n``` python\n(FTSBook\n .select(fn.snippet(FTSBook.as_entity()))\n .where(FTSBook.match('python')))\n```\n", "Hi,\r\nIt seems the as_entity() method does not exist any more.\r\nHow should I use fn.snippet now?", "You can use `._meta.entity` property instead:\r\n\r\n```python\r\nFTSBook.select(fn.snippet(FTSBook._meta.entity))\r\n```" ]

[]

[]

[ "You need to use playhouse.postgres_ext.PostgresqlExtDatabase.\n", "Ohh thanks... :+1: \n" ]

[]

[]

[ "Can you share your code and the SQL? Its hard to help without any clues you know...\n", "Also what database are you using? If you can't share your exact query can you give me an example that fails in a similar way?\n", "Please comment and I will re-open.\n", "I'm using postgres as my database.\n\nHere is my code:\n\n``` python\nq1 = ASRank.select().where(ASRank.snapshot == '2014-02-04').order_by(ASRank.byte_rank).limit(10)\nq2 = ASRank.select().where(ASRank.snapshot == '2014-02-04').order_by(ASRank.flow_rank).limit(10)\nq = q1 | q2\n```\n\nwhich results in:\n\n``` sql\nSELECT \"t2\".\"id\", \"t2\".\"snapshot_id\", \"t2\".\"asn\", \"t2\".\"byte_rank\", \"t2\".\"flow_rank\", \"t2\".\"bytes\", \"t2\".\"flows\" \nFROM \"asrank\" AS t2 \nWHERE (\"t2\".\"snapshot_id\" = 2014-02-04) ORDER BY \"t2\".\"byte_rank\" LIMIT 10 \nUNION \nSELECT \"t2\".\"id\", \"t2\".\"snapshot_id\", \"t2\".\"asn\", \"t2\".\"byte_rank\", \"t2\".\"flow_rank\", \"t2\".\"bytes\", \"t2\".\"flows\" \nFROM \"asrank\" AS t2 \nWHERE (\"t2\".\"snapshot_id\" = 2014-02-04) ORDER BY \"t2\".\"flow_rank\" LIMIT 10 ORDER BY \"t1\".\"byte_rank\"\n```\n", "Ouch, yes I've verified the bug on both Postgresql and SQLite.\n", "I believe these problems should now be fixed in `master`. SQLite does not support limit/order by in the components of a compound query, but since you're using Postgres this ended up being a problem of fixing the parentheses. Your query should now be working if you pull the latest code. I'll make a new release in the next week or two.\n", "Oh, and thank you very much for reporting this!!\n", "Thanks for fixing the issue quickly.\n" ]

[]

[]

[ "If you use `IntegerField` then it will not be auto-incrementing. Instead you should use `PrimaryKeyField` which contains the appropriate \"AUTO INCREMENT\" clause.\n" ]

[]

[]

[ "Thank you for the effort you put into this, but I don't have any plans to merge this functionality, as it seems to me something that would be a better fit for your own library code.\n", "The use case for this is actually very common. Many, if not most, DBs have some reference tables that are populated with an initial set of values and later added to, and those tables are usually the target of foreign key relations. The peewee docs even contain a section on how to do it, \"Manually specifying primary keys\". If a peewee user follows the docs, then after re-activating auto_increment in a Postgresql database, as instructed by the docs, they are going to encounter a duplicate key constraint violation, unless they do something like what I've done. If the sequence update is not done by peewee then the user must code it as a special case for Postgresql if they wish to target different DBs. \n\nFor a feature as frequently used as auto-increment, and with such a troublesome incompatibility between Postgresql and the other back-end DBs, isn't it worth one method on the model to keep peewee client code DB neutral? \n", "> The use case for this is actually very common\n\nI'd beg to differ, as in the 4+ years peewee's been around, you're the first to ask for a sequence updating helper.\n\nMy stance is that relying on particular values for auto-incremented, sequence-backed columns is an anti-pattern. I understand that maybe you're restoring data, but in the very rare cases I've done that all I had to do was restore the data then set the currval of the sequence -- it was a one-time operation, just another part of restoring from backup.\n\nThe docs you've referenced even emphasize that this is a one-time type operation:\n\n> To handle this on a **one-off** basis, you can simply tell peewee to turn off auto_increment during the import\n", "I agree that it's a one-off operation, though possibly one time for each new deployment. But when you are finished with it the DB might be broken (if it's postgresql), or it might not. The docs don't mention that your DB might be broken, and there's no database neutral code that you can write to make sure that it's fixed. That's all I'm trying to create, the simplest possible uniform way to fix any DB after inserting explicit keys into an auto-increment table. \n" ]

[]

[]

[ "Well, first of all, two queries is not N+1 queries. N+1 queries happens when you have a loop, for instance, and for every result in the outer query you execute an additional query.\n\nSo no, it's not N+1.\n\nIn fact, it is only 1 query, which you can verify by [enabling query logging](http://docs.peewee-orm.com/en/latest/peewee/database.html#logging-queries).\n\nCalling `dicts()` or `tuples()` will not evaluate the query. Select queries are evaluated when you call `execute()` on them, iterate over them, call `len()` on them, or index into them.\n", "Excellent, just what I needed to know. Thanks.\n" ]

[]

[]

[]

[]

[]

[ "I didn't think it made a lot of sense to return the IDs for bulk inserts. If inserting a lot of rows, it could mean a lot of data being transferred back over the wire for all those inserts. Furthermore, insert_many() doesn't return instances, so what would be the point of having the IDs?\n\nAlso, the behavior prior to 2.5 was to only return the latest insert ID of a batch. \n", "In my particular use case, I'm using peewee in a service that ingests large amounts of data and writes it to the db (postgres). We have another service that is responsible for updating the search index (elasticsearch), and it drastically simplifies things if I can pass the list of new IDs to the search index service after the bulk insert.\n\nI'm not convinced this behavior makes sense as a default, but I do think it's nice to have as an option, especially because the behavior in 2.5 is nearly there. Like I mentioned, I'd be happy to rewrite it to be a non-default option for `insert_many()` / `InsertQuery` -- shouldn't be hard.\n\nEDIT: The tests ran fine in my environment, so I'll have to look at why they're failing on Travis a little later.\n", "> I do think it's nice to have as an option\n\nSounds good to me.\n", "You can now call:\n\n``` python\ndata = [{'username': username} for username in list_of_usernames]\nuser_ids = User.insert_many(data).return_id_list().execute()\nprint user_ids\n```\n", "http://docs.peewee-orm.com/en/latest/peewee/api.html#InsertQuery.return_id_list\n" ]

[]

[]

[ "I don't think `array_lower` does what you are expecting there. It returns the lower bound of the requested array dimension.\n", "So, can you let me know, how can i resolve this issue ?\n", "I am not sure. Can you express this query using plain SQL? If you can give me the correct SQL, then I will help you translate it to utilize peewee.\n" ]

[]

[]

[ "Hello Charles,\n\nThis is a minor modification to enable pwiz to create models that preserve the column ordering from the original source DB. I needed that in order to use dump files created with native Postgresql tools from the original DB. The new behavior an option so that default pwiz behavior is unchanged. I hope that you will find it to be a useful addition. \n\n Ed\n", "Nice work. Could you add a unit test?\n", "Hi Charles,\n\nAll fixes in. Please let me know if you think the way I've divided up the EXPECTED text is \"too clever by half\" and if you'd prefer just plain text for the new test. \n\n Ed\n", "> Please let me know if you think the way I've divided up the EXPECTED text is \"too clever by half\" and if you'd prefer just plain text for the new test.\n\nerrr yeah\n", "I switched to full explicit text for each expected value per your preference. Also prevented test failure of unsupported feature under Python 2.6\n", "Thank you so much! I've mergd a very slightly modified version of your changes. I also caught an unreported bug while messing with the tests, so even better!\n" ]

[]

[]

[ "`post._data['user']`\n", "Thank you Charles! :)\n" ]

[]

[]

[ "This follows the pattern used by SQLAlchemy:\n\nhttp://docs.sqlalchemy.org/en/rel_0_9/core/engines.html#sqlite\n\nThis translates to `sqlite://<no host, so empty>/<path to database>`.\n", "See also: https://pythonhosted.org/Flask-SQLAlchemy/config.html\n", "Thanks!\n" ]

[]

[]

[ "- 08b3c0ee03576e16965b9003b38b4bad4b126fb3\n- 3ced2b6d3955243fb815250158c44af94b212781\n- 2f114136cb823f5a5b0c936dcc93d313c9e4f368\n" ]

[]

[]

[ "This appears to not work at all with sqlite, and so is probably a non-starter. Feel free to close if you agree.\n", "I don't believe it is supported by Postgres either, so yes I think I will close it out. If your deletes happen infrequently you could always recourse to having a \"raw\" SQL query to accomplish them, if that makes things easier.\n\nThanks for the good bug report and for being understanding about the wontfix.\n", "This is supported in Postgresql with the [`USING` clause](https://www.postgresql.org/docs/current/static/sql-delete.html)\n\n> PostgreSQL lets you reference columns of other tables in the WHERE condition by specifying the other tables in the USING clause. For example, to delete all films produced by a given producer, one can do:\n> \n> `DELETE FROM films USING producers\n> WHERE producer_id = producers.id AND producers.name = 'foo';`\n\nBut since at the Peewee level you can just use s [raw query](http://stackoverflow.com/a/38068039/1161906), so I'm not sure this changes anything. \n" ]